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

Rename increasingly inaccuratly named distance member of QueryEdge to weight

Browse Source
This commit is contained in:
Patrick Niklaus 2016-05-12 18:50:10 +02:00 committed by Patrick Niklaus
parent 1d994da12b
commit b8795c7341
13 changed files with 253 additions and 260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
include/contractor/graph_contractor.hpp
View File

@ -37,22 +37,22 @@ class GraphContractor
struct ContractorEdgeData struct ContractorEdgeData
{ {
ContractorEdgeData() ContractorEdgeData()
: distance(0), id(0), originalEdges(0), shortcut(0), forward(0), backward(0), : weight(0), id(0), originalEdges(0), shortcut(0), forward(0), backward(0),
is_original_via_node_ID(false) is_original_via_node_ID(false)
{ {
} }
ContractorEdgeData(unsigned distance, ContractorEdgeData(unsigned weight,
unsigned original_edges, unsigned original_edges,
unsigned id, unsigned id,
bool shortcut, bool shortcut,
bool forward, bool forward,
bool backward) bool backward)
: distance(distance), id(id), : weight(weight), id(id), originalEdges(std::min((unsigned)1 << 28, original_edges)),
originalEdges(std::min((unsigned)1 << 28, original_edges)), shortcut(shortcut), shortcut(shortcut), forward(forward), backward(backward),
forward(forward), backward(backward), is_original_via_node_ID(false) is_original_via_node_ID(false)
{ {
} }
unsigned distance; unsigned weight;
unsigned id; unsigned id;
unsigned originalEdges : 28; unsigned originalEdges : 28;
bool shortcut : 1; bool shortcut : 1;
@ -153,8 +153,6 @@ class GraphContractor
const auto dend = input_edge_list.dend(); const auto dend = input_edge_list.dend();
for (auto diter = input_edge_list.dbegin(); diter != dend; ++diter) for (auto diter = input_edge_list.dbegin(); diter != dend; ++diter)
{ {
BOOST_ASSERT_MSG(static_cast<unsigned int>(std::max(diter->weight, 1)) > 0,
"edge distance < 1");
#ifndef NDEBUG #ifndef NDEBUG
if (static_cast<unsigned int>(std::max(diter->weight, 1)) > 24 * 60 * 60 * 10) if (static_cast<unsigned int>(std::max(diter->weight, 1)) > 24 * 60 * 60 * 10)
{ {
@ -210,26 +208,26 @@ class GraphContractor
forward_edge.data.shortcut = reverse_edge.data.shortcut = false; forward_edge.data.shortcut = reverse_edge.data.shortcut = false;
forward_edge.data.id = reverse_edge.data.id = id; forward_edge.data.id = reverse_edge.data.id = id;
forward_edge.data.originalEdges = reverse_edge.data.originalEdges = 1; forward_edge.data.originalEdges = reverse_edge.data.originalEdges = 1;
forward_edge.data.distance = reverse_edge.data.distance = INVALID_EDGE_WEIGHT; forward_edge.data.weight = reverse_edge.data.weight = INVALID_EDGE_WEIGHT;
// remove parallel edges // remove parallel edges
while (i < edges.size() && edges[i].source == source && edges[i].target == target) while (i < edges.size() && edges[i].source == source && edges[i].target == target)
{ {
if (edges[i].data.forward) if (edges[i].data.forward)
{ {
forward_edge.data.distance = forward_edge.data.weight =
std::min(edges[i].data.distance, forward_edge.data.distance); std::min(edges[i].data.weight, forward_edge.data.weight);
} }
if (edges[i].data.backward) if (edges[i].data.backward)
{ {
reverse_edge.data.distance = reverse_edge.data.weight =
std::min(edges[i].data.distance, reverse_edge.data.distance); std::min(edges[i].data.weight, reverse_edge.data.weight);
} }
++i; ++i;
} }
// merge edges (s,t) and (t,s) into bidirectional edge // merge edges (s,t) and (t,s) into bidirectional edge
if (forward_edge.data.distance == reverse_edge.data.distance) if (forward_edge.data.weight == reverse_edge.data.weight)
{ {
if ((int)forward_edge.data.distance != INVALID_EDGE_WEIGHT) if ((int)forward_edge.data.weight != INVALID_EDGE_WEIGHT)
{ {
forward_edge.data.backward = true; forward_edge.data.backward = true;
edges[edge++] = forward_edge; edges[edge++] = forward_edge;
@ -237,11 +235,11 @@ class GraphContractor
} }
else else
{ // insert seperate edges { // insert seperate edges
if (((int)forward_edge.data.distance) != INVALID_EDGE_WEIGHT) if (((int)forward_edge.data.weight) != INVALID_EDGE_WEIGHT)
{ {
edges[edge++] = forward_edge; edges[edge++] = forward_edge;
} }
if ((int)reverse_edge.data.distance != INVALID_EDGE_WEIGHT) if ((int)reverse_edge.data.weight != INVALID_EDGE_WEIGHT)
{ {
edges[edge++] = reverse_edge; edges[edge++] = reverse_edge;
} }
@ -530,7 +528,7 @@ class GraphContractor
contractor_graph->GetEdgeData(current_edge_ID); contractor_graph->GetEdgeData(current_edge_ID);
if (current_data.shortcut && edge.data.forward == current_data.forward && if (current_data.shortcut && edge.data.forward == current_data.forward &&
edge.data.backward == current_data.backward && edge.data.backward == current_data.backward &&
edge.data.distance < current_data.distance) edge.data.weight < current_data.weight)
{ {
// found a duplicate edge with smaller weight, update it. // found a duplicate edge with smaller weight, update it.
current_data = edge.data; current_data = edge.data;
@ -645,7 +643,7 @@ class GraphContractor
} }
BOOST_ASSERT_MSG(SPECIAL_NODEID != new_edge.source, "Source id invalid"); BOOST_ASSERT_MSG(SPECIAL_NODEID != new_edge.source, "Source id invalid");
BOOST_ASSERT_MSG(SPECIAL_NODEID != new_edge.target, "Target id invalid"); BOOST_ASSERT_MSG(SPECIAL_NODEID != new_edge.target, "Target id invalid");
new_edge.data.distance = data.distance; new_edge.data.weight = data.weight;
new_edge.data.shortcut = data.shortcut; new_edge.data.shortcut = data.shortcut;
if (!data.is_original_via_node_ID && !orig_node_id_from_new_node_id_map.empty()) if (!data.is_original_via_node_ID && !orig_node_id_from_new_node_id_map.empty())
{ {
@ -677,7 +675,7 @@ class GraphContractor
private: private:
inline void RelaxNode(const NodeID node, inline void RelaxNode(const NodeID node,
const NodeID forbidden_node, const NodeID forbidden_node,
const int distance, const int weight,
ContractorHeap &heap) ContractorHeap &heap)
{ {
const short current_hop = heap.GetData(node).hop + 1; const short current_hop = heap.GetData(node).hop + 1;
@ -693,23 +691,23 @@ class GraphContractor
{ {
continue; continue;
} }
const int to_distance = distance + data.distance; const int to_weight = weight + data.weight;
// New Node discovered -> Add to Heap + Node Info Storage // New Node discovered -> Add to Heap + Node Info Storage
if (!heap.WasInserted(to)) if (!heap.WasInserted(to))
{ {
heap.Insert(to, to_distance, ContractorHeapData{current_hop, false}); heap.Insert(to, to_weight, ContractorHeapData{current_hop, false});
} }
// Found a shorter Path -> Update distance // Found a shorter Path -> Update weight
else if (to_distance < heap.GetKey(to)) else if (to_weight < heap.GetKey(to))
{ {
heap.DecreaseKey(to, to_distance); heap.DecreaseKey(to, to_weight);
heap.GetData(to).hop = current_hop; heap.GetData(to).hop = current_hop;
} }
} }
} }
inline void Dijkstra(const int max_distance, inline void Dijkstra(const int max_weight,
const unsigned number_of_targets, const unsigned number_of_targets,
const int max_nodes, const int max_nodes,
ContractorThreadData &data, ContractorThreadData &data,
@ -723,12 +721,12 @@ class GraphContractor
while (!heap.Empty()) while (!heap.Empty())
{ {
const NodeID node = heap.DeleteMin(); const NodeID node = heap.DeleteMin();
const auto distance = heap.GetKey(node); const auto weight = heap.GetKey(node);
if (++nodes > max_nodes) if (++nodes > max_nodes)
{ {
return; return;
} }
if (distance > max_distance) if (weight > max_weight)
{ {
return; return;
} }
@ -743,7 +741,7 @@ class GraphContractor
} }
} }
RelaxNode(node, middle_node, distance, heap); RelaxNode(node, middle_node, weight, heap);
} }
} }
@ -806,7 +804,7 @@ class GraphContractor
heap.Clear(); heap.Clear();
heap.Insert(source, 0, ContractorHeapData{}); heap.Insert(source, 0, ContractorHeapData{});
int max_distance = 0; int max_weight = 0;
unsigned number_of_targets = 0; unsigned number_of_targets = 0;
for (auto out_edge : contractor_graph->GetAdjacentEdgeRange(node)) for (auto out_edge : contractor_graph->GetAdjacentEdgeRange(node))
@ -820,10 +818,10 @@ class GraphContractor
if (node == target) if (node == target)
continue; continue;
const EdgeWeight path_distance = in_data.distance + out_data.distance; const EdgeWeight path_weight = in_data.weight + out_data.weight;
if (target == source) if (target == source)
{ {
if (path_distance < node_weights[node]) if (path_weight < node_weights[node])
{ {
if (RUNSIMULATION) if (RUNSIMULATION)
{ {
@ -832,7 +830,7 @@ class GraphContractor
// CAREFUL: This only works due to the independent node-setting. This // CAREFUL: This only works due to the independent node-setting. This
// guarantees that source is not connected to another node that is // guarantees that source is not connected to another node that is
// contracted // contracted
node_weights[source] = path_distance + 1; node_weights[source] = path_weight + 1;
BOOST_ASSERT(stats != nullptr); BOOST_ASSERT(stats != nullptr);
stats->edges_added_count += 2; stats->edges_added_count += 2;
stats->original_edges_added_count += stats->original_edges_added_count +=
@ -843,10 +841,10 @@ class GraphContractor
// CAREFUL: This only works due to the independent node-setting. This // CAREFUL: This only works due to the independent node-setting. This
// guarantees that source is not connected to another node that is // guarantees that source is not connected to another node that is
// contracted // contracted
node_weights[source] = path_distance; // make sure to prune better node_weights[source] = path_weight; // make sure to prune better
inserted_edges.emplace_back(source, inserted_edges.emplace_back(source,
target, target,
path_distance, path_weight,
out_data.originalEdges + out_data.originalEdges +
in_data.originalEdges, in_data.originalEdges,
node, node,
@ -856,7 +854,7 @@ class GraphContractor
inserted_edges.emplace_back(target, inserted_edges.emplace_back(target,
source, source,
path_distance, path_weight,
out_data.originalEdges + out_data.originalEdges +
in_data.originalEdges, in_data.originalEdges,
node, node,
@ -867,7 +865,7 @@ class GraphContractor
} }
continue; continue;
} }
max_distance = std::max(max_distance, path_distance); max_weight = std::max(max_weight, path_weight);
if (!heap.WasInserted(target)) if (!heap.WasInserted(target))
{ {
heap.Insert(target, INVALID_EDGE_WEIGHT, ContractorHeapData{0, true}); heap.Insert(target, INVALID_EDGE_WEIGHT, ContractorHeapData{0, true});
@ -878,13 +876,12 @@ class GraphContractor
if (RUNSIMULATION) if (RUNSIMULATION)
{ {
const int constexpr SIMULATION_SEARCH_SPACE_SIZE = 1000; const int constexpr SIMULATION_SEARCH_SPACE_SIZE = 1000;
Dijkstra( Dijkstra(max_weight, number_of_targets, SIMULATION_SEARCH_SPACE_SIZE, *data, node);
max_distance, number_of_targets, SIMULATION_SEARCH_SPACE_SIZE, *data, node);
} }
else else
{ {
const int constexpr FULL_SEARCH_SPACE_SIZE = 2000; const int constexpr FULL_SEARCH_SPACE_SIZE = 2000;
Dijkstra(max_distance, number_of_targets, FULL_SEARCH_SPACE_SIZE, *data, node); Dijkstra(max_weight, number_of_targets, FULL_SEARCH_SPACE_SIZE, *data, node);
} }
for (auto out_edge : contractor_graph->GetAdjacentEdgeRange(node)) for (auto out_edge : contractor_graph->GetAdjacentEdgeRange(node))
{ {
@ -896,9 +893,9 @@ class GraphContractor
const NodeID target = contractor_graph->GetTarget(out_edge); const NodeID target = contractor_graph->GetTarget(out_edge);
if (target == node) if (target == node)
continue; continue;
const int path_distance = in_data.distance + out_data.distance; const int path_weight = in_data.weight + out_data.weight;
const int distance = heap.GetKey(target); const int weight = heap.GetKey(target);
if (path_distance < distance) if (path_weight < weight)
{ {
if (RUNSIMULATION) if (RUNSIMULATION)
{ {
@ -911,7 +908,7 @@ class GraphContractor
{ {
inserted_edges.emplace_back(source, inserted_edges.emplace_back(source,
target, target,
path_distance, path_weight,
out_data.originalEdges + in_data.originalEdges, out_data.originalEdges + in_data.originalEdges,
node, node,
SHORTCUT_ARC, SHORTCUT_ARC,
@ -920,7 +917,7 @@ class GraphContractor
inserted_edges.emplace_back(target, inserted_edges.emplace_back(target,
source, source,
path_distance, path_weight,
out_data.originalEdges + in_data.originalEdges, out_data.originalEdges + in_data.originalEdges,
node, node,
SHORTCUT_ARC, SHORTCUT_ARC,
@ -948,7 +945,7 @@ class GraphContractor
{ {
continue; continue;
} }
if (inserted_edges[other].data.distance != inserted_edges[i].data.distance) if (inserted_edges[other].data.weight != inserted_edges[i].data.weight)
{ {
continue; continue;
} }

8
include/contractor/query_edge.hpp
View File

@ -16,11 +16,11 @@ struct QueryEdge
NodeID target; NodeID target;
struct EdgeData struct EdgeData
{ {
EdgeData() : id(0), shortcut(false), distance(0), forward(false), backward(false) {} EdgeData() : id(0), shortcut(false), weight(0), forward(false), backward(false) {}
template <class OtherT> EdgeData(const OtherT &other) template <class OtherT> EdgeData(const OtherT &other)
{ {
distance = other.distance; weight = other.weight;
shortcut = other.shortcut; shortcut = other.shortcut;
id = other.id; id = other.id;
forward = other.forward; forward = other.forward;
@ -28,7 +28,7 @@ struct QueryEdge
} }
NodeID id : 31; NodeID id : 31;
bool shortcut : 1; bool shortcut : 1;
int distance : 30; int weight : 30;
bool forward : 1; bool forward : 1;
bool backward : 1; bool backward : 1;
} data; } data;
@ -48,7 +48,7 @@ struct QueryEdge
bool operator==(const QueryEdge &right) const bool operator==(const QueryEdge &right) const
{ {
return (source == right.source && target == right.target && return (source == right.source && target == right.target &&
data.distance == right.data.distance && data.shortcut == right.data.shortcut && data.weight == right.data.weight && data.shortcut == right.data.shortcut &&
data.forward == right.data.forward && data.backward == right.data.backward && data.forward == right.data.forward && data.backward == right.data.backward &&
data.id == right.data.id); data.id == right.data.id);
} }

1
include/engine/datafacade/internal_datafacade.hpp
View File

@ -89,7 +89,6 @@ class InternalDataFacade final : public BaseDataFacade
util::ShM<EdgeWeight, false>::vector m_geometry_fwd_weight_list; util::ShM<EdgeWeight, false>::vector m_geometry_fwd_weight_list;
util::ShM<EdgeWeight, false>::vector m_geometry_rev_weight_list; util::ShM<EdgeWeight, false>::vector m_geometry_rev_weight_list;
util::ShM<bool, false>::vector m_is_core_node; util::ShM<bool, false>::vector m_is_core_node;
util::ShM<unsigned, false>::vector m_segment_weights;
util::ShM<uint8_t, false>::vector m_datasource_list; util::ShM<uint8_t, false>::vector m_datasource_list;
util::ShM<std::string, false>::vector m_datasource_names; util::ShM<std::string, false>::vector m_datasource_names;
util::ShM<std::uint32_t, false>::vector m_lane_description_offsets; util::ShM<std::uint32_t, false>::vector m_lane_description_offsets;

2
include/engine/edge_unpacker.hpp
View File

@ -82,7 +82,7 @@ inline void UnpackCHPath(const DataFacadeT &facade,
BOOST_ASSERT_MSG(smaller_edge_id != SPECIAL_EDGEID, "Invalid smaller edge ID"); BOOST_ASSERT_MSG(smaller_edge_id != SPECIAL_EDGEID, "Invalid smaller edge ID");
const auto &data = facade.GetEdgeData(smaller_edge_id); const auto &data = facade.GetEdgeData(smaller_edge_id);
BOOST_ASSERT_MSG(data.distance != std::numeric_limits<EdgeWeight>::max(), BOOST_ASSERT_MSG(data.weight != std::numeric_limits<EdgeWeight>::max(),
"edge weight invalid"); "edge weight invalid");
// If the edge is a shortcut, we need to add the two halfs to the stack. // If the edge is a shortcut, we need to add the two halfs to the stack.

132
include/engine/routing_algorithms/alternative_path.hpp
View File

@ -79,7 +79,7 @@ class AlternativeRouting final
QueryHeap &forward_heap2 = *(engine_working_data.forward_heap_2); QueryHeap &forward_heap2 = *(engine_working_data.forward_heap_2);
QueryHeap &reverse_heap2 = *(engine_working_data.reverse_heap_2); QueryHeap &reverse_heap2 = *(engine_working_data.reverse_heap_2);
int upper_bound_to_shortest_path_distance = INVALID_EDGE_WEIGHT; int upper_bound_to_shortest_path_weight = INVALID_EDGE_WEIGHT;
NodeID middle_node = SPECIAL_NODEID; NodeID middle_node = SPECIAL_NODEID;
const EdgeWeight min_edge_offset = const EdgeWeight min_edge_offset =
std::min(phantom_node_pair.source_phantom.forward_segment_id.enabled std::min(phantom_node_pair.source_phantom.forward_segment_id.enabled
@ -132,7 +132,7 @@ class AlternativeRouting final
forward_heap1, forward_heap1,
reverse_heap1, reverse_heap1,
&middle_node, &middle_node,
&upper_bound_to_shortest_path_distance, &upper_bound_to_shortest_path_weight,
via_node_candidate_list, via_node_candidate_list,
forward_search_space, forward_search_space,
min_edge_offset); min_edge_offset);
@ -143,14 +143,14 @@ class AlternativeRouting final
forward_heap1, forward_heap1,
reverse_heap1, reverse_heap1,
&middle_node, &middle_node,
&upper_bound_to_shortest_path_distance, &upper_bound_to_shortest_path_weight,
via_node_candidate_list, via_node_candidate_list,
reverse_search_space, reverse_search_space,
min_edge_offset); min_edge_offset);
} }
} }
if (INVALID_EDGE_WEIGHT == upper_bound_to_shortest_path_distance) if (INVALID_EDGE_WEIGHT == upper_bound_to_shortest_path_weight)
{ {
return; return;
} }
@ -163,7 +163,7 @@ class AlternativeRouting final
std::vector<NodeID> packed_reverse_path; std::vector<NodeID> packed_reverse_path;
const bool path_is_a_loop = const bool path_is_a_loop =
upper_bound_to_shortest_path_distance != upper_bound_to_shortest_path_weight !=
forward_heap1.GetKey(middle_node) + reverse_heap1.GetKey(middle_node); forward_heap1.GetKey(middle_node) + reverse_heap1.GetKey(middle_node);
if (path_is_a_loop) if (path_is_a_loop)
{ {
@ -257,14 +257,13 @@ class AlternativeRouting final
const int approximated_sharing = fwd_sharing + rev_sharing; const int approximated_sharing = fwd_sharing + rev_sharing;
const int approximated_length = forward_heap1.GetKey(node) + reverse_heap1.GetKey(node); const int approximated_length = forward_heap1.GetKey(node) + reverse_heap1.GetKey(node);
const bool length_passes = const bool length_passes =
(approximated_length < (approximated_length < upper_bound_to_shortest_path_weight * (1 + VIAPATH_EPSILON));
upper_bound_to_shortest_path_distance * (1 + VIAPATH_EPSILON));
const bool sharing_passes = const bool sharing_passes =
(approximated_sharing <= upper_bound_to_shortest_path_distance * VIAPATH_GAMMA); (approximated_sharing <= upper_bound_to_shortest_path_weight * VIAPATH_GAMMA);
const bool stretch_passes = const bool stretch_passes =
(approximated_length - approximated_sharing) < (approximated_length - approximated_sharing) <
((1. + VIAPATH_ALPHA) * ((1. + VIAPATH_ALPHA) *
(upper_bound_to_shortest_path_distance - approximated_sharing)); (upper_bound_to_shortest_path_weight - approximated_sharing));
if (length_passes && sharing_passes && stretch_passes) if (length_passes && sharing_passes && stretch_passes)
{ {
@ -293,9 +292,9 @@ class AlternativeRouting final
packed_shortest_path, packed_shortest_path,
min_edge_offset); min_edge_offset);
const int maximum_allowed_sharing = const int maximum_allowed_sharing =
static_cast<int>(upper_bound_to_shortest_path_distance * VIAPATH_GAMMA); static_cast<int>(upper_bound_to_shortest_path_weight * VIAPATH_GAMMA);
if (sharing_of_via_path <= maximum_allowed_sharing && if (sharing_of_via_path <= maximum_allowed_sharing &&
length_of_via_path <= upper_bound_to_shortest_path_distance * (1 + VIAPATH_EPSILON)) length_of_via_path <= upper_bound_to_shortest_path_weight * (1 + VIAPATH_EPSILON))
{ {
ranked_candidates_list.emplace_back(node, length_of_via_path, sharing_of_via_path); ranked_candidates_list.emplace_back(node, length_of_via_path, sharing_of_via_path);
} }
@ -313,7 +312,7 @@ class AlternativeRouting final
forward_heap2, forward_heap2,
reverse_heap2, reverse_heap2,
candidate, candidate,
upper_bound_to_shortest_path_distance, upper_bound_to_shortest_path_weight,
&length_of_via_path, &length_of_via_path,
&s_v_middle, &s_v_middle,
&v_t_middle, &v_t_middle,
@ -326,7 +325,7 @@ class AlternativeRouting final
} }
// Unpack shortest path and alternative, if they exist // Unpack shortest path and alternative, if they exist
if (INVALID_EDGE_WEIGHT != upper_bound_to_shortest_path_distance) if (INVALID_EDGE_WEIGHT != upper_bound_to_shortest_path_weight)
{ {
BOOST_ASSERT(!packed_shortest_path.empty()); BOOST_ASSERT(!packed_shortest_path.empty());
raw_route_data.unpacked_path_segments.resize(1); raw_route_data.unpacked_path_segments.resize(1);
@ -345,7 +344,7 @@ class AlternativeRouting final
phantom_node_pair, phantom_node_pair,
// -- unpacked output // -- unpacked output
raw_route_data.unpacked_path_segments.front()); raw_route_data.unpacked_path_segments.front());
raw_route_data.shortest_path_length = upper_bound_to_shortest_path_distance; raw_route_data.shortest_path_length = upper_bound_to_shortest_path_weight;
} }
if (SPECIAL_NODEID != selected_via_node) if (SPECIAL_NODEID != selected_via_node)
@ -488,7 +487,7 @@ class AlternativeRouting final
{ {
EdgeID edgeID = facade.FindEdgeInEitherDirection(packed_s_v_path[current_node], EdgeID edgeID = facade.FindEdgeInEitherDirection(packed_s_v_path[current_node],
packed_s_v_path[current_node + 1]); packed_s_v_path[current_node + 1]);
*sharing_of_via_path += facade.GetEdgeData(edgeID).distance; *sharing_of_via_path += facade.GetEdgeData(edgeID).weight;
} }
else else
{ {
@ -521,7 +520,7 @@ class AlternativeRouting final
EdgeID selected_edge = EdgeID selected_edge =
facade.FindEdgeInEitherDirection(partially_unpacked_via_path[current_node], facade.FindEdgeInEitherDirection(partially_unpacked_via_path[current_node],
partially_unpacked_via_path[current_node + 1]); partially_unpacked_via_path[current_node + 1]);
*sharing_of_via_path += facade.GetEdgeData(selected_edge).distance; *sharing_of_via_path += facade.GetEdgeData(selected_edge).weight;
} }
// Second, partially unpack v-->t in reverse order until paths deviate and note lengths // Second, partially unpack v-->t in reverse order until paths deviate and note lengths
@ -536,7 +535,7 @@ class AlternativeRouting final
{ {
EdgeID edgeID = facade.FindEdgeInEitherDirection( EdgeID edgeID = facade.FindEdgeInEitherDirection(
packed_v_t_path[via_path_index - 1], packed_v_t_path[via_path_index]); packed_v_t_path[via_path_index - 1], packed_v_t_path[via_path_index]);
*sharing_of_via_path += facade.GetEdgeData(edgeID).distance; *sharing_of_via_path += facade.GetEdgeData(edgeID).weight;
} }
else else
{ {
@ -568,7 +567,7 @@ class AlternativeRouting final
EdgeID edgeID = facade.FindEdgeInEitherDirection( EdgeID edgeID = facade.FindEdgeInEitherDirection(
partially_unpacked_via_path[via_path_index - 1], partially_unpacked_via_path[via_path_index - 1],
partially_unpacked_via_path[via_path_index]); partially_unpacked_via_path[via_path_index]);
*sharing_of_via_path += facade.GetEdgeData(edgeID).distance; *sharing_of_via_path += facade.GetEdgeData(edgeID).weight;
} }
else else
{ {
@ -606,7 +605,7 @@ class AlternativeRouting final
// packed_alternate_path[aindex] << "," << packed_alternate_path[aindex+1] << ")"; // packed_alternate_path[aindex] << "," << packed_alternate_path[aindex+1] << ")";
// EdgeID edgeID = facade->FindEdgeInEitherDirection(packed_alternate_path[aindex], // EdgeID edgeID = facade->FindEdgeInEitherDirection(packed_alternate_path[aindex],
// packed_alternate_path[aindex+1]); // packed_alternate_path[aindex+1]);
// sharing += facade->GetEdgeData(edgeID).distance; // sharing += facade->GetEdgeData(edgeID).weight;
// ++aindex; // ++aindex;
// } // }
@ -618,7 +617,7 @@ class AlternativeRouting final
// packed_shortest_path[bindex-1]) ) { // packed_shortest_path[bindex-1]) ) {
// EdgeID edgeID = facade->FindEdgeInEitherDirection(packed_alternate_path[aindex], // EdgeID edgeID = facade->FindEdgeInEitherDirection(packed_alternate_path[aindex],
// packed_alternate_path[aindex-1]); // packed_alternate_path[aindex-1]);
// sharing += facade->GetEdgeData(edgeID).distance; // sharing += facade->GetEdgeData(edgeID).weight;
// --aindex; --bindex; // --aindex; --bindex;
// } // }
// return sharing; // return sharing;
@ -630,7 +629,7 @@ class AlternativeRouting final
QueryHeap &heap1, QueryHeap &heap1,
QueryHeap &heap2, QueryHeap &heap2,
NodeID *middle_node, NodeID *middle_node,
int *upper_bound_to_shortest_path_distance, int *upper_bound_to_shortest_path_weight,
std::vector<NodeID> &search_space_intersection, std::vector<NodeID> &search_space_intersection,
std::vector<SearchSpaceEdge> &search_space, std::vector<SearchSpaceEdge> &search_space,
const EdgeWeight min_edge_offset) const const EdgeWeight min_edge_offset) const
@ -639,16 +638,16 @@ class AlternativeRouting final
QueryHeap &reverse_heap = (is_forward_directed ? heap2 : heap1); QueryHeap &reverse_heap = (is_forward_directed ? heap2 : heap1);
const NodeID node = forward_heap.DeleteMin(); const NodeID node = forward_heap.DeleteMin();
const int distance = forward_heap.GetKey(node); const int weight = forward_heap.GetKey(node);
// const NodeID parentnode = forward_heap.GetData(node).parent; // const NodeID parentnode = forward_heap.GetData(node).parent;
// util::SimpleLogger().Write() << (is_forward_directed ? "[fwd] " : "[rev] ") << "settled // util::SimpleLogger().Write() << (is_forward_directed ? "[fwd] " : "[rev] ") << "settled
// edge (" // edge ("
// << parentnode << "," << node << "), dist: " << distance; // << parentnode << "," << node << "), dist: " << weight;
const int scaled_distance = const int scaled_weight =
static_cast<int>((distance + min_edge_offset) / (1. + VIAPATH_EPSILON)); static_cast<int>((weight + min_edge_offset) / (1. + VIAPATH_EPSILON));
if ((INVALID_EDGE_WEIGHT != *upper_bound_to_shortest_path_distance) && if ((INVALID_EDGE_WEIGHT != *upper_bound_to_shortest_path_weight) &&
(scaled_distance > *upper_bound_to_shortest_path_distance)) (scaled_weight > *upper_bound_to_shortest_path_weight))
{ {
forward_heap.DeleteAll(); forward_heap.DeleteAll();
return; return;
@ -659,31 +658,31 @@ class AlternativeRouting final
if (reverse_heap.WasInserted(node)) if (reverse_heap.WasInserted(node))
{ {
search_space_intersection.emplace_back(node); search_space_intersection.emplace_back(node);
const int new_distance = reverse_heap.GetKey(node) + distance; const int new_weight = reverse_heap.GetKey(node) + weight;
if (new_distance < *upper_bound_to_shortest_path_distance) if (new_weight < *upper_bound_to_shortest_path_weight)
{ {
if (new_distance >= 0) if (new_weight >= 0)
{ {
*middle_node = node; *middle_node = node;
*upper_bound_to_shortest_path_distance = new_distance; *upper_bound_to_shortest_path_weight = new_weight;
// util::SimpleLogger().Write() << "accepted middle_node " << *middle_node // util::SimpleLogger().Write() << "accepted middle_node " << *middle_node
// << " at // << " at
// distance " << new_distance; // weight " << new_weight;
// } else { // } else {
// util::SimpleLogger().Write() << "discarded middle_node " << *middle_node // util::SimpleLogger().Write() << "discarded middle_node " << *middle_node
// << " // << "
// at distance " << new_distance; // at weight " << new_weight;
} }
else else
{ {
// check whether there is a loop present at the node // check whether there is a loop present at the node
const auto loop_distance = super::GetLoopWeight(facade, node); const auto loop_weight = super::GetLoopWeight(facade, node);
const int new_distance_with_loop = new_distance + loop_distance; const int new_weight_with_loop = new_weight + loop_weight;
if (loop_distance != INVALID_EDGE_WEIGHT && if (loop_weight != INVALID_EDGE_WEIGHT &&
new_distance_with_loop <= *upper_bound_to_shortest_path_distance) new_weight_with_loop <= *upper_bound_to_shortest_path_weight)
{ {
*middle_node = node; *middle_node = node;
*upper_bound_to_shortest_path_distance = loop_distance; *upper_bound_to_shortest_path_weight = loop_weight;
} }
} }
} }
@ -696,25 +695,24 @@ class AlternativeRouting final
(is_forward_directed ? data.forward : data.backward); (is_forward_directed ? data.forward : data.backward);
if (edge_is_forward_directed) if (edge_is_forward_directed)
{ {
const NodeID to = facade.GetTarget(edge); const NodeID to = facade.GetTarget(edge);
const int edge_weight = data.distance; const int edge_weight = data.weight;
BOOST_ASSERT(edge_weight > 0); BOOST_ASSERT(edge_weight > 0);
const int to_distance = distance + edge_weight; const int to_weight = weight + edge_weight;
// New Node discovered -> Add to Heap + Node Info Storage // New Node discovered -> Add to Heap + Node Info Storage
if (!forward_heap.WasInserted(to)) if (!forward_heap.WasInserted(to))
{ {
forward_heap.Insert(to, to_distance, node); forward_heap.Insert(to, to_weight, node);
} }
// Found a shorter Path -> Update distance // Found a shorter Path -> Update weight
else if (to_distance < forward_heap.GetKey(to)) else if (to_weight < forward_heap.GetKey(to))
{ {
// new parent // new parent
forward_heap.GetData(to).parent = node; forward_heap.GetData(to).parent = node;
// decreased distance // decreased weight
forward_heap.DecreaseKey(to, to_distance); forward_heap.DecreaseKey(to, to_weight);
} }
} }
} }
@ -806,7 +804,7 @@ class AlternativeRouting final
return false; return false;
} }
const int T_threshold = static_cast<int>(VIAPATH_EPSILON * length_of_shortest_path); const int T_threshold = static_cast<int>(VIAPATH_EPSILON * length_of_shortest_path);
int unpacked_until_distance = 0; int unpacked_until_weight = 0;
std::stack<SearchSpaceEdge> unpack_stack; std::stack<SearchSpaceEdge> unpack_stack;
// Traverse path s-->v // Traverse path s-->v
@ -814,14 +812,14 @@ class AlternativeRouting final
{ {
const EdgeID current_edge_id = const EdgeID current_edge_id =
facade.FindEdgeInEitherDirection(packed_s_v_path[i - 1], packed_s_v_path[i]); facade.FindEdgeInEitherDirection(packed_s_v_path[i - 1], packed_s_v_path[i]);
const int length_of_current_edge = facade.GetEdgeData(current_edge_id).distance; const int length_of_current_edge = facade.GetEdgeData(current_edge_id).weight;
if ((length_of_current_edge + unpacked_until_distance) >= T_threshold) if ((length_of_current_edge + unpacked_until_weight) >= T_threshold)
{ {
unpack_stack.emplace(packed_s_v_path[i - 1], packed_s_v_path[i]); unpack_stack.emplace(packed_s_v_path[i - 1], packed_s_v_path[i]);
} }
else else
{ {
unpacked_until_distance += length_of_current_edge; unpacked_until_weight += length_of_current_edge;
s_P = packed_s_v_path[i - 1]; s_P = packed_s_v_path[i - 1];
} }
} }
@ -846,30 +844,30 @@ class AlternativeRouting final
const EdgeID second_segment_edge_id = const EdgeID second_segment_edge_id =
facade.FindEdgeInEitherDirection(via_path_middle_node_id, via_path_edge.second); facade.FindEdgeInEitherDirection(via_path_middle_node_id, via_path_edge.second);
const int second_segment_length = const int second_segment_length =
facade.GetEdgeData(second_segment_edge_id).distance; facade.GetEdgeData(second_segment_edge_id).weight;
// attention: !unpacking in reverse! // attention: !unpacking in reverse!
// Check if second segment is the one to go over treshold? if yes add second segment // Check if second segment is the one to go over treshold? if yes add second segment
// to stack, else push first segment to stack and add distance of second one. // to stack, else push first segment to stack and add weight of second one.
if (unpacked_until_distance + second_segment_length >= T_threshold) if (unpacked_until_weight + second_segment_length >= T_threshold)
{ {
unpack_stack.emplace(via_path_middle_node_id, via_path_edge.second); unpack_stack.emplace(via_path_middle_node_id, via_path_edge.second);
} }
else else
{ {
unpacked_until_distance += second_segment_length; unpacked_until_weight += second_segment_length;
unpack_stack.emplace(via_path_edge.first, via_path_middle_node_id); unpack_stack.emplace(via_path_edge.first, via_path_middle_node_id);
} }
} }
else else
{ {
// edge is not a shortcut, set the start node for T-Test to end of edge. // edge is not a shortcut, set the start node for T-Test to end of edge.
unpacked_until_distance += current_edge_data.distance; unpacked_until_weight += current_edge_data.weight;
s_P = via_path_edge.first; s_P = via_path_edge.first;
} }
} }
int t_test_path_length = unpacked_until_distance; int t_test_path_length = unpacked_until_weight;
unpacked_until_distance = 0; unpacked_until_weight = 0;
// Traverse path s-->v // Traverse path s-->v
BOOST_ASSERT(!packed_v_t_path.empty()); BOOST_ASSERT(!packed_v_t_path.empty());
for (unsigned i = 0, packed_path_length = static_cast<unsigned>(packed_v_t_path.size() - 1); for (unsigned i = 0, packed_path_length = static_cast<unsigned>(packed_v_t_path.size() - 1);
@ -878,14 +876,14 @@ class AlternativeRouting final
{ {
const EdgeID edgeID = const EdgeID edgeID =
facade.FindEdgeInEitherDirection(packed_v_t_path[i], packed_v_t_path[i + 1]); facade.FindEdgeInEitherDirection(packed_v_t_path[i], packed_v_t_path[i + 1]);
int length_of_current_edge = facade.GetEdgeData(edgeID).distance; int length_of_current_edge = facade.GetEdgeData(edgeID).weight;
if (length_of_current_edge + unpacked_until_distance >= T_threshold) if (length_of_current_edge + unpacked_until_weight >= T_threshold)
{ {
unpack_stack.emplace(packed_v_t_path[i], packed_v_t_path[i + 1]); unpack_stack.emplace(packed_v_t_path[i], packed_v_t_path[i + 1]);
} }
else else
{ {
unpacked_until_distance += length_of_current_edge; unpacked_until_weight += length_of_current_edge;
t_P = packed_v_t_path[i + 1]; t_P = packed_v_t_path[i + 1];
} }
} }
@ -908,29 +906,29 @@ class AlternativeRouting final
const NodeID middleOfViaPath = current_edge_data.id; const NodeID middleOfViaPath = current_edge_data.id;
EdgeID edgeIDOfFirstSegment = EdgeID edgeIDOfFirstSegment =
facade.FindEdgeInEitherDirection(via_path_edge.first, middleOfViaPath); facade.FindEdgeInEitherDirection(via_path_edge.first, middleOfViaPath);
int lengthOfFirstSegment = facade.GetEdgeData(edgeIDOfFirstSegment).distance; int lengthOfFirstSegment = facade.GetEdgeData(edgeIDOfFirstSegment).weight;
// Check if first segment is the one to go over treshold? if yes first segment to // Check if first segment is the one to go over treshold? if yes first segment to
// stack, else push second segment to stack and add distance of first one. // stack, else push second segment to stack and add weight of first one.
if (unpacked_until_distance + lengthOfFirstSegment >= T_threshold) if (unpacked_until_weight + lengthOfFirstSegment >= T_threshold)
{ {
unpack_stack.emplace(via_path_edge.first, middleOfViaPath); unpack_stack.emplace(via_path_edge.first, middleOfViaPath);
} }
else else
{ {
unpacked_until_distance += lengthOfFirstSegment; unpacked_until_weight += lengthOfFirstSegment;
unpack_stack.emplace(middleOfViaPath, via_path_edge.second); unpack_stack.emplace(middleOfViaPath, via_path_edge.second);
} }
} }
else else
{ {
// edge is not a shortcut, set the start node for T-Test to end of edge. // edge is not a shortcut, set the start node for T-Test to end of edge.
unpacked_until_distance += current_edge_data.distance; unpacked_until_weight += current_edge_data.weight;
t_P = via_path_edge.second; t_P = via_path_edge.second;
} }
} }
t_test_path_length += unpacked_until_distance; t_test_path_length += unpacked_until_weight;
// Run actual T-Test query and compare if distances equal. // Run actual T-Test query and compare if weight equal.
engine_working_data.InitializeOrClearThirdThreadLocalStorage(facade.GetNumberOfNodes()); engine_working_data.InitializeOrClearThirdThreadLocalStorage(facade.GetNumberOfNodes());
QueryHeap &forward_heap3 = *engine_working_data.forward_heap_3; QueryHeap &forward_heap3 = *engine_working_data.forward_heap_3;

12
include/engine/routing_algorithms/direct_shortest_path.hpp
View File

@ -43,7 +43,7 @@ class DirectShortestPathRouting final
const std::vector<PhantomNodes> &phantom_nodes_vector, const std::vector<PhantomNodes> &phantom_nodes_vector,
InternalRouteResult &raw_route_data) const InternalRouteResult &raw_route_data) const
{ {
// Get distance to next pair of target nodes. // Get weight to next pair of target nodes.
BOOST_ASSERT_MSG(1 == phantom_nodes_vector.size(), BOOST_ASSERT_MSG(1 == phantom_nodes_vector.size(),
"Direct Shortest Path Query only accepts a single source and target pair. " "Direct Shortest Path Query only accepts a single source and target pair. "
"Multiple ones have been specified."); "Multiple ones have been specified.");
@ -87,7 +87,7 @@ class DirectShortestPathRouting final
target_phantom.reverse_segment_id.id); target_phantom.reverse_segment_id.id);
} }
int distance = INVALID_EDGE_WEIGHT; int weight = INVALID_EDGE_WEIGHT;
std::vector<NodeID> packed_leg; std::vector<NodeID> packed_leg;
const bool constexpr DO_NOT_FORCE_LOOPS = const bool constexpr DO_NOT_FORCE_LOOPS =
@ -107,7 +107,7 @@ class DirectShortestPathRouting final
reverse_heap, reverse_heap,
forward_core_heap, forward_core_heap,
reverse_core_heap, reverse_core_heap,
distance, weight,
packed_leg, packed_leg,
DO_NOT_FORCE_LOOPS, DO_NOT_FORCE_LOOPS,
DO_NOT_FORCE_LOOPS); DO_NOT_FORCE_LOOPS);
@ -117,14 +117,14 @@ class DirectShortestPathRouting final
super::Search(facade, super::Search(facade,
forward_heap, forward_heap,
reverse_heap, reverse_heap,
distance, weight,
packed_leg, packed_leg,
DO_NOT_FORCE_LOOPS, DO_NOT_FORCE_LOOPS,
DO_NOT_FORCE_LOOPS); DO_NOT_FORCE_LOOPS);
} }
// No path found for both target nodes? // No path found for both target nodes?
if (INVALID_EDGE_WEIGHT == distance) if (INVALID_EDGE_WEIGHT == weight)
{ {
raw_route_data.shortest_path_length = INVALID_EDGE_WEIGHT; raw_route_data.shortest_path_length = INVALID_EDGE_WEIGHT;
raw_route_data.alternative_path_length = INVALID_EDGE_WEIGHT; raw_route_data.alternative_path_length = INVALID_EDGE_WEIGHT;
@ -133,7 +133,7 @@ class DirectShortestPathRouting final
BOOST_ASSERT_MSG(!packed_leg.empty(), "packed path empty"); BOOST_ASSERT_MSG(!packed_leg.empty(), "packed path empty");
raw_route_data.shortest_path_length = distance; raw_route_data.shortest_path_length = weight;
raw_route_data.unpacked_path_segments.resize(1); raw_route_data.unpacked_path_segments.resize(1);
raw_route_data.source_traversed_in_reverse.push_back( raw_route_data.source_traversed_in_reverse.push_back(
(packed_leg.front() != phantom_node_pair.source_phantom.forward_segment_id.id)); (packed_leg.front() != phantom_node_pair.source_phantom.forward_segment_id.id));

66
include/engine/routing_algorithms/many_to_many.hpp
View File

@ -29,10 +29,10 @@ class ManyToManyRouting final
struct NodeBucket struct NodeBucket
{ {
unsigned target_id; // essentially a row in the distance matrix unsigned target_id; // essentially a row in the weight matrix
EdgeWeight distance; EdgeWeight weight;
NodeBucket(const unsigned target_id, const EdgeWeight distance) NodeBucket(const unsigned target_id, const EdgeWeight weight)
: target_id(target_id), distance(distance) : target_id(target_id), weight(weight)
{ {
} }
}; };
@ -68,7 +68,7 @@ class ManyToManyRouting final
unsigned column_idx = 0; unsigned column_idx = 0;
const auto search_target_phantom = [&](const PhantomNode &phantom) { const auto search_target_phantom = [&](const PhantomNode &phantom) {
query_heap.Clear(); query_heap.Clear();
// insert target(s) at distance 0 // insert target(s) at weight 0
if (phantom.forward_segment_id.enabled) if (phantom.forward_segment_id.enabled)
{ {
@ -95,7 +95,7 @@ class ManyToManyRouting final
unsigned row_idx = 0; unsigned row_idx = 0;
const auto search_source_phantom = [&](const PhantomNode &phantom) { const auto search_source_phantom = [&](const PhantomNode &phantom) {
query_heap.Clear(); query_heap.Clear();
// insert target(s) at distance 0 // insert target(s) at weight 0
if (phantom.forward_segment_id.enabled) if (phantom.forward_segment_id.enabled)
{ {
@ -166,7 +166,7 @@ class ManyToManyRouting final
std::vector<EdgeWeight> &result_table) const std::vector<EdgeWeight> &result_table) const
{ {
const NodeID node = query_heap.DeleteMin(); const NodeID node = query_heap.DeleteMin();
const int source_distance = query_heap.GetKey(node); const int source_weight = query_heap.GetKey(node);
// check if each encountered node has an entry // check if each encountered node has an entry
const auto bucket_iterator = search_space_with_buckets.find(node); const auto bucket_iterator = search_space_with_buckets.find(node);
@ -178,30 +178,30 @@ class ManyToManyRouting final
{ {
// get target id from bucket entry // get target id from bucket entry
const unsigned column_idx = current_bucket.target_id; const unsigned column_idx = current_bucket.target_id;
const int target_distance = current_bucket.distance; const int target_weight = current_bucket.weight;
auto &current_distance = result_table[row_idx * number_of_targets + column_idx]; auto &current_weight = result_table[row_idx * number_of_targets + column_idx];
// check if new distance is better // check if new weight is better
const EdgeWeight new_distance = source_distance + target_distance; const EdgeWeight new_weight = source_weight + target_weight;
if (new_distance < 0) if (new_weight < 0)
{ {
const EdgeWeight loop_weight = super::GetLoopWeight(facade, node); const EdgeWeight loop_weight = super::GetLoopWeight(facade, node);
const int new_distance_with_loop = new_distance + loop_weight; const int new_weight_with_loop = new_weight + loop_weight;
if (loop_weight != INVALID_EDGE_WEIGHT && new_distance_with_loop >= 0) if (loop_weight != INVALID_EDGE_WEIGHT && new_weight_with_loop >= 0)
{ {
current_distance = std::min(current_distance, new_distance_with_loop); current_weight = std::min(current_weight, new_weight_with_loop);
} }
} }
else if (new_distance < current_distance) else if (new_weight < current_weight)
{ {
result_table[row_idx * number_of_targets + column_idx] = new_distance; result_table[row_idx * number_of_targets + column_idx] = new_weight;
} }
} }
} }
if (StallAtNode<true>(facade, node, source_distance, query_heap)) if (StallAtNode<true>(facade, node, source_weight, query_heap))
{ {
return; return;
} }
RelaxOutgoingEdges<true>(facade, node, source_distance, query_heap); RelaxOutgoingEdges<true>(facade, node, source_weight, query_heap);
} }
void BackwardRoutingStep(const DataFacadeT &facade, void BackwardRoutingStep(const DataFacadeT &facade,
@ -210,23 +210,23 @@ class ManyToManyRouting final
SearchSpaceWithBuckets &search_space_with_buckets) const SearchSpaceWithBuckets &search_space_with_buckets) const
{ {
const NodeID node = query_heap.DeleteMin(); const NodeID node = query_heap.DeleteMin();
const int target_distance = query_heap.GetKey(node); const int target_weight = query_heap.GetKey(node);
// store settled nodes in search space bucket // store settled nodes in search space bucket
search_space_with_buckets[node].emplace_back(column_idx, target_distance); search_space_with_buckets[node].emplace_back(column_idx, target_weight);
if (StallAtNode<false>(facade, node, target_distance, query_heap)) if (StallAtNode<false>(facade, node, target_weight, query_heap))
{ {
return; return;
} }
RelaxOutgoingEdges<false>(facade, node, target_distance, query_heap); RelaxOutgoingEdges<false>(facade, node, target_weight, query_heap);
} }
template <bool forward_direction> template <bool forward_direction>
inline void RelaxOutgoingEdges(const DataFacadeT &facade, inline void RelaxOutgoingEdges(const DataFacadeT &facade,
const NodeID node, const NodeID node,
const EdgeWeight distance, const EdgeWeight weight,
QueryHeap &query_heap) const QueryHeap &query_heap) const
{ {
for (auto edge : facade.GetAdjacentEdgeRange(node)) for (auto edge : facade.GetAdjacentEdgeRange(node))
@ -236,22 +236,22 @@ class ManyToManyRouting final
if (direction_flag) if (direction_flag)
{ {
const NodeID to = facade.GetTarget(edge); const NodeID to = facade.GetTarget(edge);
const int edge_weight = data.distance; const int edge_weight = data.weight;
BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid"); BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
const int to_distance = distance + edge_weight; const int to_weight = weight + edge_weight;
// New Node discovered -> Add to Heap + Node Info Storage // New Node discovered -> Add to Heap + Node Info Storage
if (!query_heap.WasInserted(to)) if (!query_heap.WasInserted(to))
{ {
query_heap.Insert(to, to_distance, node); query_heap.Insert(to, to_weight, node);
} }
// Found a shorter Path -> Update distance // Found a shorter Path -> Update weight
else if (to_distance < query_heap.GetKey(to)) else if (to_weight < query_heap.GetKey(to))
{ {
// new parent // new parent
query_heap.GetData(to).parent = node; query_heap.GetData(to).parent = node;
query_heap.DecreaseKey(to, to_distance); query_heap.DecreaseKey(to, to_weight);
} }
} }
} }
@ -261,7 +261,7 @@ class ManyToManyRouting final
template <bool forward_direction> template <bool forward_direction>
inline bool StallAtNode(const DataFacadeT &facade, inline bool StallAtNode(const DataFacadeT &facade,
const NodeID node, const NodeID node,
const EdgeWeight distance, const EdgeWeight weight,
QueryHeap &query_heap) const QueryHeap &query_heap) const
{ {
for (auto edge : facade.GetAdjacentEdgeRange(node)) for (auto edge : facade.GetAdjacentEdgeRange(node))
@ -271,11 +271,11 @@ class ManyToManyRouting final
if (reverse_flag) if (reverse_flag)
{ {
const NodeID to = facade.GetTarget(edge); const NodeID to = facade.GetTarget(edge);
const int edge_weight = data.distance; const int edge_weight = data.weight;
BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid"); BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
if (query_heap.WasInserted(to)) if (query_heap.WasInserted(to))
{ {
if (query_heap.GetKey(to) + edge_weight < distance) if (query_heap.GetKey(to) + edge_weight < weight)
{ {
return true; return true;
} }

87
include/engine/routing_algorithms/routing_base.hpp
View File

@ -76,19 +76,19 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
const bool force_loop_reverse) const const bool force_loop_reverse) const
{ {
const NodeID node = forward_heap.DeleteMin(); const NodeID node = forward_heap.DeleteMin();
const std::int32_t distance = forward_heap.GetKey(node); const std::int32_t weight = forward_heap.GetKey(node);
if (reverse_heap.WasInserted(node)) if (reverse_heap.WasInserted(node))
{ {
const std::int32_t new_distance = reverse_heap.GetKey(node) + distance; const std::int32_t new_weight = reverse_heap.GetKey(node) + weight;
if (new_distance < upper_bound) if (new_weight < upper_bound)
{ {
// if loops are forced, they are so at the source // if loops are forced, they are so at the source
if ((force_loop_forward && forward_heap.GetData(node).parent == node) || if ((force_loop_forward && forward_heap.GetData(node).parent == node) ||
(force_loop_reverse && reverse_heap.GetData(node).parent == node) || (force_loop_reverse && reverse_heap.GetData(node).parent == node) ||
// in this case we are looking at a bi-directional way where the source // in this case we are looking at a bi-directional way where the source
// and target phantom are on the same edge based node // and target phantom are on the same edge based node
new_distance < 0) new_weight < 0)
{ {
// check whether there is a loop present at the node // check whether there is a loop present at the node
for (const auto edge : facade.GetAdjacentEdgeRange(node)) for (const auto edge : facade.GetAdjacentEdgeRange(node))
@ -101,12 +101,12 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
const NodeID to = facade.GetTarget(edge); const NodeID to = facade.GetTarget(edge);
if (to == node) if (to == node)
{ {
const EdgeWeight edge_weight = data.distance; const EdgeWeight edge_weight = data.weight;
const std::int32_t loop_distance = new_distance + edge_weight; const std::int32_t loop_weight = new_weight + edge_weight;
if (loop_distance >= 0 && loop_distance < upper_bound) if (loop_weight >= 0 && loop_weight < upper_bound)
{ {
middle_node_id = node; middle_node_id = node;
upper_bound = loop_distance; upper_bound = loop_weight;
} }
} }
} }
@ -114,18 +114,18 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
} }
else else
{ {
BOOST_ASSERT(new_distance >= 0); BOOST_ASSERT(new_weight >= 0);
middle_node_id = node; middle_node_id = node;
upper_bound = new_distance; upper_bound = new_weight;
} }
} }
} }
// make sure we don't terminate too early if we initialize the distance // make sure we don't terminate too early if we initialize the weight
// for the nodes in the forward heap with the forward/reverse offset // for the nodes in the forward heap with the forward/reverse offset
BOOST_ASSERT(min_edge_offset <= 0); BOOST_ASSERT(min_edge_offset <= 0);
if (distance + min_edge_offset > upper_bound) if (weight + min_edge_offset > upper_bound)
{ {
forward_heap.DeleteAll(); forward_heap.DeleteAll();
return; return;
@ -141,13 +141,13 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
if (reverse_flag) if (reverse_flag)
{ {
const NodeID to = facade.GetTarget(edge); const NodeID to = facade.GetTarget(edge);
const EdgeWeight edge_weight = data.distance; const EdgeWeight edge_weight = data.weight;
BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid"); BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
if (forward_heap.WasInserted(to)) if (forward_heap.WasInserted(to))
{ {
if (forward_heap.GetKey(to) + edge_weight < distance) if (forward_heap.GetKey(to) + edge_weight < weight)
{ {
return; return;
} }
@ -162,24 +162,23 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
bool forward_directionFlag = (forward_direction ? data.forward : data.backward); bool forward_directionFlag = (forward_direction ? data.forward : data.backward);
if (forward_directionFlag) if (forward_directionFlag)
{ {
const NodeID to = facade.GetTarget(edge); const NodeID to = facade.GetTarget(edge);
const EdgeWeight edge_weight = data.distance; const EdgeWeight edge_weight = data.weight;
BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid"); BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
const int to_distance = distance + edge_weight; const int to_weight = weight + edge_weight;
// New Node discovered -> Add to Heap + Node Info Storage // New Node discovered -> Add to Heap + Node Info Storage
if (!forward_heap.WasInserted(to)) if (!forward_heap.WasInserted(to))
{ {
forward_heap.Insert(to, to_distance, node); forward_heap.Insert(to, to_weight, node);
} }
// Found a shorter Path -> Update distance // Found a shorter Path -> Update weight
else if (to_distance < forward_heap.GetKey(to)) else if (to_weight < forward_heap.GetKey(to))
{ {
// new parent // new parent
forward_heap.GetData(to).parent = node; forward_heap.GetData(to).parent = node;
forward_heap.DecreaseKey(to, to_distance); forward_heap.DecreaseKey(to, to_weight);
} }
} }
} }
@ -196,7 +195,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
const NodeID to = facade.GetTarget(edge); const NodeID to = facade.GetTarget(edge);
if (to == node) if (to == node)
{ {
loop_weight = std::min(loop_weight, data.distance); loop_weight = std::min(loop_weight, data.weight);
} }
} }
} }
@ -300,7 +299,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
unpacked_path.back().entry_classid = facade.GetEntryClassID(edge_data.id); unpacked_path.back().entry_classid = facade.GetEntryClassID(edge_data.id);
unpacked_path.back().turn_instruction = turn_instruction; unpacked_path.back().turn_instruction = turn_instruction;
unpacked_path.back().duration_until_turn += (edge_data.distance - total_weight); unpacked_path.back().duration_until_turn += (edge_data.weight - total_weight);
unpacked_path.back().pre_turn_bearing = facade.PreTurnBearing(edge_data.id); unpacked_path.back().pre_turn_bearing = facade.PreTurnBearing(edge_data.id);
unpacked_path.back().post_turn_bearing = facade.PostTurnBearing(edge_data.id); unpacked_path.back().post_turn_bearing = facade.PostTurnBearing(edge_data.id);
}); });
@ -400,7 +399,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
// there is no equivalent to a node-based node in an edge-expanded graph. // there is no equivalent to a node-based node in an edge-expanded graph.
// two equivalent routes may start (or end) at different node-based edges // two equivalent routes may start (or end) at different node-based edges
// as they are added with the offset how much "distance" on the edge // as they are added with the offset how much "weight" on the edge
// has already been traversed. Depending on offset one needs to remove // has already been traversed. Depending on offset one needs to remove
// the last node. // the last node.
if (unpacked_path.size() > 1) if (unpacked_path.size() > 1)
@ -483,14 +482,14 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
void Search(const DataFacadeT &facade, void Search(const DataFacadeT &facade,
SearchEngineData::QueryHeap &forward_heap, SearchEngineData::QueryHeap &forward_heap,
SearchEngineData::QueryHeap &reverse_heap, SearchEngineData::QueryHeap &reverse_heap,
std::int32_t &distance, std::int32_t &weight,
std::vector<NodeID> &packed_leg, std::vector<NodeID> &packed_leg,
const bool force_loop_forward, const bool force_loop_forward,
const bool force_loop_reverse, const bool force_loop_reverse,
const int duration_upper_bound = INVALID_EDGE_WEIGHT) const const int duration_upper_bound = INVALID_EDGE_WEIGHT) const
{ {
NodeID middle = SPECIAL_NODEID; NodeID middle = SPECIAL_NODEID;
distance = duration_upper_bound; weight = duration_upper_bound;
// get offset to account for offsets on phantom nodes on compressed edges // get offset to account for offsets on phantom nodes on compressed edges
const auto min_edge_offset = std::min(0, forward_heap.MinKey()); const auto min_edge_offset = std::min(0, forward_heap.MinKey());
@ -508,7 +507,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
forward_heap, forward_heap,
reverse_heap, reverse_heap,
middle, middle,
distance, weight,
min_edge_offset, min_edge_offset,
true, true,
STALLING_ENABLED, STALLING_ENABLED,
@ -521,7 +520,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
reverse_heap, reverse_heap,
forward_heap, forward_heap,
middle, middle,
distance, weight,
min_edge_offset, min_edge_offset,
false, false,
STALLING_ENABLED, STALLING_ENABLED,
@ -531,18 +530,18 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
} }
// No path found for both target nodes? // No path found for both target nodes?
if (duration_upper_bound <= distance || SPECIAL_NODEID == middle) if (duration_upper_bound <= weight || SPECIAL_NODEID == middle)
{ {
distance = INVALID_EDGE_WEIGHT; weight = INVALID_EDGE_WEIGHT;
return; return;
} }
// Was a paths over one of the forward/reverse nodes not found? // Was a paths over one of the forward/reverse nodes not found?
BOOST_ASSERT_MSG((SPECIAL_NODEID != middle && INVALID_EDGE_WEIGHT != distance), BOOST_ASSERT_MSG((SPECIAL_NODEID != middle && INVALID_EDGE_WEIGHT != weight),
"no path found"); "no path found");
// make sure to correctly unpack loops // make sure to correctly unpack loops
if (distance != forward_heap.GetKey(middle) + reverse_heap.GetKey(middle)) if (weight != forward_heap.GetKey(middle) + reverse_heap.GetKey(middle))
{ {
// self loop makes up the full path // self loop makes up the full path
packed_leg.push_back(middle); packed_leg.push_back(middle);
@ -568,14 +567,14 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
SearchEngineData::QueryHeap &reverse_heap, SearchEngineData::QueryHeap &reverse_heap,
SearchEngineData::QueryHeap &forward_core_heap, SearchEngineData::QueryHeap &forward_core_heap,
SearchEngineData::QueryHeap &reverse_core_heap, SearchEngineData::QueryHeap &reverse_core_heap,
int &distance, int &weight,
std::vector<NodeID> &packed_leg, std::vector<NodeID> &packed_leg,
const bool force_loop_forward, const bool force_loop_forward,
const bool force_loop_reverse, const bool force_loop_reverse,
int duration_upper_bound = INVALID_EDGE_WEIGHT) const int duration_upper_bound = INVALID_EDGE_WEIGHT) const
{ {
NodeID middle = SPECIAL_NODEID; NodeID middle = SPECIAL_NODEID;
distance = duration_upper_bound; weight = duration_upper_bound;
using CoreEntryPoint = std::tuple<NodeID, EdgeWeight, NodeID>; using CoreEntryPoint = std::tuple<NodeID, EdgeWeight, NodeID>;
std::vector<CoreEntryPoint> forward_entry_points; std::vector<CoreEntryPoint> forward_entry_points;
@ -604,7 +603,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
forward_heap, forward_heap,
reverse_heap, reverse_heap,
middle, middle,
distance, weight,
min_edge_offset, min_edge_offset,
true, true,
STALLING_ENABLED, STALLING_ENABLED,
@ -626,7 +625,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
reverse_heap, reverse_heap,
forward_heap, forward_heap,
middle, middle,
distance, weight,
min_edge_offset, min_edge_offset,
false, false,
STALLING_ENABLED, STALLING_ENABLED,
@ -673,13 +672,13 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
// run two-target Dijkstra routing step on core with termination criterion // run two-target Dijkstra routing step on core with termination criterion
const constexpr bool STALLING_DISABLED = false; const constexpr bool STALLING_DISABLED = false;
while (0 < forward_core_heap.Size() && 0 < reverse_core_heap.Size() && while (0 < forward_core_heap.Size() && 0 < reverse_core_heap.Size() &&
distance > (forward_core_heap.MinKey() + reverse_core_heap.MinKey())) weight > (forward_core_heap.MinKey() + reverse_core_heap.MinKey()))
{ {
RoutingStep(facade, RoutingStep(facade,
forward_core_heap, forward_core_heap,
reverse_core_heap, reverse_core_heap,
middle, middle,
distance, weight,
min_core_edge_offset, min_core_edge_offset,
true, true,
STALLING_DISABLED, STALLING_DISABLED,
@ -690,7 +689,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
reverse_core_heap, reverse_core_heap,
forward_core_heap, forward_core_heap,
middle, middle,
distance, weight,
min_core_edge_offset, min_core_edge_offset,
false, false,
STALLING_DISABLED, STALLING_DISABLED,
@ -699,20 +698,20 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
} }
// No path found for both target nodes? // No path found for both target nodes?
if (duration_upper_bound <= distance || SPECIAL_NODEID == middle) if (duration_upper_bound <= weight || SPECIAL_NODEID == middle)
{ {
distance = INVALID_EDGE_WEIGHT; weight = INVALID_EDGE_WEIGHT;
return; return;
} }
// Was a paths over one of the forward/reverse nodes not found? // Was a paths over one of the forward/reverse nodes not found?
BOOST_ASSERT_MSG((SPECIAL_NODEID != middle && INVALID_EDGE_WEIGHT != distance), BOOST_ASSERT_MSG((SPECIAL_NODEID != middle && INVALID_EDGE_WEIGHT != weight),
"no path found"); "no path found");
// we need to unpack sub path from core heaps // we need to unpack sub path from core heaps
if (facade.IsCoreNode(middle)) if (facade.IsCoreNode(middle))
{ {
if (distance != forward_core_heap.GetKey(middle) + reverse_core_heap.GetKey(middle)) if (weight != forward_core_heap.GetKey(middle) + reverse_core_heap.GetKey(middle))
{ {
// self loop // self loop
BOOST_ASSERT(forward_core_heap.GetData(middle).parent == middle && BOOST_ASSERT(forward_core_heap.GetData(middle).parent == middle &&
@ -734,7 +733,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
} }
else else
{ {
if (distance != forward_heap.GetKey(middle) + reverse_heap.GetKey(middle)) if (weight != forward_heap.GetKey(middle) + reverse_heap.GetKey(middle))
{ {
// self loop // self loop
BOOST_ASSERT(forward_heap.GetData(middle).parent == middle && BOOST_ASSERT(forward_heap.GetData(middle).parent == middle &&

96
include/engine/routing_algorithms/shortest_path.hpp
View File

@ -48,9 +48,9 @@ class ShortestPathRouting final
const bool search_to_reverse_node, const bool search_to_reverse_node,
const PhantomNode &source_phantom, const PhantomNode &source_phantom,
const PhantomNode &target_phantom, const PhantomNode &target_phantom,
const int total_distance_to_forward, const int total_weight_to_forward,
const int total_distance_to_reverse, const int total_weight_to_reverse,
int &new_total_distance, int &new_total_weight,
std::vector<NodeID> &leg_packed_path) const std::vector<NodeID> &leg_packed_path) const
{ {
forward_heap.Clear(); forward_heap.Clear();
@ -102,7 +102,7 @@ class ShortestPathRouting final
reverse_heap, reverse_heap,
forward_core_heap, forward_core_heap,
reverse_core_heap, reverse_core_heap,
new_total_distance, new_total_weight,
leg_packed_path, leg_packed_path,
needs_loop_forwad, needs_loop_forwad,
needs_loop_backwards); needs_loop_backwards);
@ -112,7 +112,7 @@ class ShortestPathRouting final
super::Search(facade, super::Search(facade,
forward_heap, forward_heap,
reverse_heap, reverse_heap,
new_total_distance, new_total_weight,
leg_packed_path, leg_packed_path,
needs_loop_forwad, needs_loop_forwad,
needs_loop_backwards); needs_loop_backwards);
@ -120,8 +120,8 @@ class ShortestPathRouting final
// if no route is found between two parts of the via-route, the entire route becomes // if no route is found between two parts of the via-route, the entire route becomes
// invalid. Adding to invalid edge weight sadly doesn't return an invalid edge weight. Here // invalid. Adding to invalid edge weight sadly doesn't return an invalid edge weight. Here
// we prevent the possible overflow, faking the addition of infinity + x == infinity // we prevent the possible overflow, faking the addition of infinity + x == infinity
if (new_total_distance != INVALID_EDGE_WEIGHT) if (new_total_weight != INVALID_EDGE_WEIGHT)
new_total_distance += std::min(total_distance_to_forward, total_distance_to_reverse); new_total_weight += std::min(total_weight_to_forward, total_weight_to_reverse);
} }
// searches shortest path between: // searches shortest path between:
@ -138,10 +138,10 @@ class ShortestPathRouting final
const bool search_to_reverse_node, const bool search_to_reverse_node,
const PhantomNode &source_phantom, const PhantomNode &source_phantom,
const PhantomNode &target_phantom, const PhantomNode &target_phantom,
const int total_distance_to_forward, const int total_weight_to_forward,
const int total_distance_to_reverse, const int total_weight_to_reverse,
int &new_total_distance_to_forward, int &new_total_weight_to_forward,
int &new_total_distance_to_reverse, int &new_total_weight_to_reverse,
std::vector<NodeID> &leg_packed_path_forward, std::vector<NodeID> &leg_packed_path_forward,
std::vector<NodeID> &leg_packed_path_reverse) const std::vector<NodeID> &leg_packed_path_reverse) const
{ {
@ -156,14 +156,14 @@ class ShortestPathRouting final
if (search_from_forward_node) if (search_from_forward_node)
{ {
forward_heap.Insert(source_phantom.forward_segment_id.id, forward_heap.Insert(source_phantom.forward_segment_id.id,
total_distance_to_forward - total_weight_to_forward -
source_phantom.GetForwardWeightPlusOffset(), source_phantom.GetForwardWeightPlusOffset(),
source_phantom.forward_segment_id.id); source_phantom.forward_segment_id.id);
} }
if (search_from_reverse_node) if (search_from_reverse_node)
{ {
forward_heap.Insert(source_phantom.reverse_segment_id.id, forward_heap.Insert(source_phantom.reverse_segment_id.id,
total_distance_to_reverse - total_weight_to_reverse -
source_phantom.GetReverseWeightPlusOffset(), source_phantom.GetReverseWeightPlusOffset(),
source_phantom.reverse_segment_id.id); source_phantom.reverse_segment_id.id);
} }
@ -181,7 +181,7 @@ class ShortestPathRouting final
reverse_heap, reverse_heap,
forward_core_heap, forward_core_heap,
reverse_core_heap, reverse_core_heap,
new_total_distance_to_forward, new_total_weight_to_forward,
leg_packed_path_forward, leg_packed_path_forward,
super::NeedsLoopForward(source_phantom, target_phantom), super::NeedsLoopForward(source_phantom, target_phantom),
DO_NOT_FORCE_LOOP); DO_NOT_FORCE_LOOP);
@ -191,7 +191,7 @@ class ShortestPathRouting final
super::Search(facade, super::Search(facade,
forward_heap, forward_heap,
reverse_heap, reverse_heap,
new_total_distance_to_forward, new_total_weight_to_forward,
leg_packed_path_forward, leg_packed_path_forward,
super::NeedsLoopForward(source_phantom, target_phantom), super::NeedsLoopForward(source_phantom, target_phantom),
DO_NOT_FORCE_LOOP); DO_NOT_FORCE_LOOP);
@ -208,14 +208,14 @@ class ShortestPathRouting final
if (search_from_forward_node) if (search_from_forward_node)
{ {
forward_heap.Insert(source_phantom.forward_segment_id.id, forward_heap.Insert(source_phantom.forward_segment_id.id,
total_distance_to_forward - total_weight_to_forward -
source_phantom.GetForwardWeightPlusOffset(), source_phantom.GetForwardWeightPlusOffset(),
source_phantom.forward_segment_id.id); source_phantom.forward_segment_id.id);
} }
if (search_from_reverse_node) if (search_from_reverse_node)
{ {
forward_heap.Insert(source_phantom.reverse_segment_id.id, forward_heap.Insert(source_phantom.reverse_segment_id.id,
total_distance_to_reverse - total_weight_to_reverse -
source_phantom.GetReverseWeightPlusOffset(), source_phantom.GetReverseWeightPlusOffset(),
source_phantom.reverse_segment_id.id); source_phantom.reverse_segment_id.id);
} }
@ -232,7 +232,7 @@ class ShortestPathRouting final
reverse_heap, reverse_heap,
forward_core_heap, forward_core_heap,
reverse_core_heap, reverse_core_heap,
new_total_distance_to_reverse, new_total_weight_to_reverse,
leg_packed_path_reverse, leg_packed_path_reverse,
DO_NOT_FORCE_LOOP, DO_NOT_FORCE_LOOP,
super::NeedsLoopBackwards(source_phantom, target_phantom)); super::NeedsLoopBackwards(source_phantom, target_phantom));
@ -242,7 +242,7 @@ class ShortestPathRouting final
super::Search(facade, super::Search(facade,
forward_heap, forward_heap,
reverse_heap, reverse_heap,
new_total_distance_to_reverse, new_total_weight_to_reverse,
leg_packed_path_reverse, leg_packed_path_reverse,
DO_NOT_FORCE_LOOP, DO_NOT_FORCE_LOOP,
super::NeedsLoopBackwards(source_phantom, target_phantom)); super::NeedsLoopBackwards(source_phantom, target_phantom));
@ -298,8 +298,8 @@ class ShortestPathRouting final
QueryHeap &forward_core_heap = *(engine_working_data.forward_heap_2); QueryHeap &forward_core_heap = *(engine_working_data.forward_heap_2);
QueryHeap &reverse_core_heap = *(engine_working_data.reverse_heap_2); QueryHeap &reverse_core_heap = *(engine_working_data.reverse_heap_2);
int total_distance_to_forward = 0; int total_weight_to_forward = 0;
int total_distance_to_reverse = 0; int total_weight_to_reverse = 0;
bool search_from_forward_node = bool search_from_forward_node =
phantom_nodes_vector.front().source_phantom.forward_segment_id.enabled; phantom_nodes_vector.front().source_phantom.forward_segment_id.enabled;
bool search_from_reverse_node = bool search_from_reverse_node =
@ -318,8 +318,8 @@ class ShortestPathRouting final
// a list of vias // a list of vias
for (const auto &phantom_node_pair : phantom_nodes_vector) for (const auto &phantom_node_pair : phantom_nodes_vector)
{ {
int new_total_distance_to_forward = INVALID_EDGE_WEIGHT; int new_total_weight_to_forward = INVALID_EDGE_WEIGHT;
int new_total_distance_to_reverse = INVALID_EDGE_WEIGHT; int new_total_weight_to_reverse = INVALID_EDGE_WEIGHT;
std::vector<NodeID> packed_leg_to_forward; std::vector<NodeID> packed_leg_to_forward;
std::vector<NodeID> packed_leg_to_reverse; std::vector<NodeID> packed_leg_to_reverse;
@ -350,22 +350,22 @@ class ShortestPathRouting final
search_to_reverse_node, search_to_reverse_node,
source_phantom, source_phantom,
target_phantom, target_phantom,
total_distance_to_forward, total_weight_to_forward,
total_distance_to_reverse, total_weight_to_reverse,
new_total_distance_to_forward, new_total_weight_to_forward,
packed_leg_to_forward); packed_leg_to_forward);
// if only the reverse node is valid (e.g. when using the match plugin) we // if only the reverse node is valid (e.g. when using the match plugin) we
// actually need to move // actually need to move
if (!target_phantom.forward_segment_id.enabled) if (!target_phantom.forward_segment_id.enabled)
{ {
BOOST_ASSERT(target_phantom.reverse_segment_id.enabled); BOOST_ASSERT(target_phantom.reverse_segment_id.enabled);
new_total_distance_to_reverse = new_total_distance_to_forward; new_total_weight_to_reverse = new_total_weight_to_forward;
packed_leg_to_reverse = std::move(packed_leg_to_forward); packed_leg_to_reverse = std::move(packed_leg_to_forward);
new_total_distance_to_forward = INVALID_EDGE_WEIGHT; new_total_weight_to_forward = INVALID_EDGE_WEIGHT;
} }
else if (target_phantom.reverse_segment_id.enabled) else if (target_phantom.reverse_segment_id.enabled)
{ {
new_total_distance_to_reverse = new_total_distance_to_forward; new_total_weight_to_reverse = new_total_weight_to_forward;
packed_leg_to_reverse = packed_leg_to_forward; packed_leg_to_reverse = packed_leg_to_forward;
} }
} }
@ -382,18 +382,18 @@ class ShortestPathRouting final
search_to_reverse_node, search_to_reverse_node,
source_phantom, source_phantom,
target_phantom, target_phantom,
total_distance_to_forward, total_weight_to_forward,
total_distance_to_reverse, total_weight_to_reverse,
new_total_distance_to_forward, new_total_weight_to_forward,
new_total_distance_to_reverse, new_total_weight_to_reverse,
packed_leg_to_forward, packed_leg_to_forward,
packed_leg_to_reverse); packed_leg_to_reverse);
} }
} }
// No path found for both target nodes? // No path found for both target nodes?
if ((INVALID_EDGE_WEIGHT == new_total_distance_to_forward) && if ((INVALID_EDGE_WEIGHT == new_total_weight_to_forward) &&
(INVALID_EDGE_WEIGHT == new_total_distance_to_reverse)) (INVALID_EDGE_WEIGHT == new_total_weight_to_reverse))
{ {
raw_route_data.shortest_path_length = INVALID_EDGE_WEIGHT; raw_route_data.shortest_path_length = INVALID_EDGE_WEIGHT;
raw_route_data.alternative_path_length = INVALID_EDGE_WEIGHT; raw_route_data.alternative_path_length = INVALID_EDGE_WEIGHT;
@ -404,16 +404,16 @@ class ShortestPathRouting final
if (current_leg > 0) if (current_leg > 0)
{ {
bool forward_to_forward = bool forward_to_forward =
(new_total_distance_to_forward != INVALID_EDGE_WEIGHT) && (new_total_weight_to_forward != INVALID_EDGE_WEIGHT) &&
packed_leg_to_forward.front() == source_phantom.forward_segment_id.id; packed_leg_to_forward.front() == source_phantom.forward_segment_id.id;
bool reverse_to_forward = bool reverse_to_forward =
(new_total_distance_to_forward != INVALID_EDGE_WEIGHT) && (new_total_weight_to_forward != INVALID_EDGE_WEIGHT) &&
packed_leg_to_forward.front() == source_phantom.reverse_segment_id.id; packed_leg_to_forward.front() == source_phantom.reverse_segment_id.id;
bool forward_to_reverse = bool forward_to_reverse =
(new_total_distance_to_reverse != INVALID_EDGE_WEIGHT) && (new_total_weight_to_reverse != INVALID_EDGE_WEIGHT) &&
packed_leg_to_reverse.front() == source_phantom.forward_segment_id.id; packed_leg_to_reverse.front() == source_phantom.forward_segment_id.id;
bool reverse_to_reverse = bool reverse_to_reverse =
(new_total_distance_to_reverse != INVALID_EDGE_WEIGHT) && (new_total_weight_to_reverse != INVALID_EDGE_WEIGHT) &&
packed_leg_to_reverse.front() == source_phantom.reverse_segment_id.id; packed_leg_to_reverse.front() == source_phantom.reverse_segment_id.id;
BOOST_ASSERT(!forward_to_forward || !reverse_to_forward); BOOST_ASSERT(!forward_to_forward || !reverse_to_forward);
@ -447,7 +447,7 @@ class ShortestPathRouting final
} }
} }
if (new_total_distance_to_forward != INVALID_EDGE_WEIGHT) if (new_total_weight_to_forward != INVALID_EDGE_WEIGHT)
{ {
BOOST_ASSERT(target_phantom.forward_segment_id.enabled); BOOST_ASSERT(target_phantom.forward_segment_id.enabled);
@ -464,7 +464,7 @@ class ShortestPathRouting final
search_from_forward_node = false; search_from_forward_node = false;
} }
if (new_total_distance_to_reverse != INVALID_EDGE_WEIGHT) if (new_total_weight_to_reverse != INVALID_EDGE_WEIGHT)
{ {
BOOST_ASSERT(target_phantom.reverse_segment_id.enabled); BOOST_ASSERT(target_phantom.reverse_segment_id.enabled);
@ -484,17 +484,17 @@ class ShortestPathRouting final
prev_packed_leg_to_forward = std::move(packed_leg_to_forward); prev_packed_leg_to_forward = std::move(packed_leg_to_forward);
prev_packed_leg_to_reverse = std::move(packed_leg_to_reverse); prev_packed_leg_to_reverse = std::move(packed_leg_to_reverse);
total_distance_to_forward = new_total_distance_to_forward; total_weight_to_forward = new_total_weight_to_forward;
total_distance_to_reverse = new_total_distance_to_reverse; total_weight_to_reverse = new_total_weight_to_reverse;
++current_leg; ++current_leg;
} }
BOOST_ASSERT(total_distance_to_forward != INVALID_EDGE_WEIGHT || BOOST_ASSERT(total_weight_to_forward != INVALID_EDGE_WEIGHT ||
total_distance_to_reverse != INVALID_EDGE_WEIGHT); total_weight_to_reverse != INVALID_EDGE_WEIGHT);
// We make sure the fastest route is always in packed_legs_to_forward // We make sure the fastest route is always in packed_legs_to_forward
if (total_distance_to_forward > total_distance_to_reverse) if (total_weight_to_forward > total_weight_to_reverse)
{ {
// insert sentinel // insert sentinel
packed_leg_to_reverse_begin.push_back(total_packed_path_to_reverse.size()); packed_leg_to_reverse_begin.push_back(total_packed_path_to_reverse.size());
@ -504,7 +504,7 @@ class ShortestPathRouting final
phantom_nodes_vector, phantom_nodes_vector,
total_packed_path_to_reverse, total_packed_path_to_reverse,
packed_leg_to_reverse_begin, packed_leg_to_reverse_begin,
total_distance_to_reverse, total_weight_to_reverse,
raw_route_data); raw_route_data);
} }
else else
@ -517,7 +517,7 @@ class ShortestPathRouting final
phantom_nodes_vector, phantom_nodes_vector,
total_packed_path_to_forward, total_packed_path_to_forward,
packed_leg_to_forward_begin, packed_leg_to_forward_begin,
total_distance_to_forward, total_weight_to_forward,
raw_route_data); raw_route_data);
} }
} }

2
include/extractor/edge_based_graph_factory.hpp
View File

@ -60,7 +60,7 @@ struct SegmentBlock
{ {
OSMNodeID this_osm_node_id; OSMNodeID this_osm_node_id;
double segment_length; double segment_length;
std::int32_t segment_weight; EdgeWeight segment_weight;
}; };
#pragma pack(pop) #pragma pack(pop)
static_assert(sizeof(SegmentBlock) == 20, "SegmentBlock is not packed correctly"); static_assert(sizeof(SegmentBlock) == 20, "SegmentBlock is not packed correctly");

6
include/util/static_graph.hpp
View File

@ -149,7 +149,7 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
} }
/** /**
* Finds the edge with the smallest `.distance` going from `from` to `to` * Finds the edge with the smallest `.weight` going from `from` to `to`
* @param from the source node ID * @param from the source node ID
* @param to the target node ID * @param to the target node ID
* @param filter a functor that returns a `bool` that determines whether an edge should be * @param filter a functor that returns a `bool` that determines whether an edge should be
@ -169,11 +169,11 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
{ {
const NodeID target = GetTarget(edge); const NodeID target = GetTarget(edge);
const auto &data = GetEdgeData(edge); const auto &data = GetEdgeData(edge);
if (target == to && data.distance < smallest_weight && if (target == to && data.weight < smallest_weight &&
std::forward<FilterFunction>(filter)(data)) std::forward<FilterFunction>(filter)(data))
{ {
smallest_edge = edge; smallest_edge = edge;
smallest_weight = data.distance; smallest_weight = data.weight;
} }
} }
return smallest_edge; return smallest_edge;

6
src/contractor/contractor.cpp
View File

@ -780,7 +780,7 @@ EdgeID Contractor::LoadEdgeExpandedGraph(
edge_segment_byte_ptr += sizeof(extractor::lookup::SegmentHeaderBlock); edge_segment_byte_ptr += sizeof(extractor::lookup::SegmentHeaderBlock);
auto previous_osm_node_id = header->previous_osm_node_id; auto previous_osm_node_id = header->previous_osm_node_id;
int new_weight = 0; EdgeWeight new_weight = 0;
int compressed_edge_nodes = static_cast<int>(header->num_osm_nodes); int compressed_edge_nodes = static_cast<int>(header->num_osm_nodes);
auto segmentblocks = auto segmentblocks =
@ -996,12 +996,12 @@ Contractor::WriteContractedGraph(unsigned max_node_id,
// every target needs to be valid // every target needs to be valid
BOOST_ASSERT(current_edge.target <= max_used_node_id); BOOST_ASSERT(current_edge.target <= max_used_node_id);
#ifndef NDEBUG #ifndef NDEBUG
if (current_edge.data.distance <= 0) if (current_edge.data.weight <= 0)
{ {
util::SimpleLogger().Write(logWARNING) util::SimpleLogger().Write(logWARNING)
<< "Edge: " << edge << ",source: " << contracted_edge_list[edge].source << "Edge: " << edge << ",source: " << contracted_edge_list[edge].source
<< ", target: " << contracted_edge_list[edge].target << ", target: " << contracted_edge_list[edge].target
<< ", dist: " << current_edge.data.distance; << ", weight: " << current_edge.data.weight;
util::SimpleLogger().Write(logWARNING) << "Failed at adjacency list of node " util::SimpleLogger().Write(logWARNING) << "Failed at adjacency list of node "
<< contracted_edge_list[edge].source << "/" << contracted_edge_list[edge].source << "/"

6
src/engine/plugins/tile.cpp
View File

@ -540,13 +540,13 @@ Status TilePlugin::HandleRequest(const std::shared_ptr<datafacade::BaseDataFacad
const auto sum_node_weight = std::accumulate( const auto sum_node_weight = std::accumulate(
forward_weight_vector.begin(), forward_weight_vector.end(), EdgeWeight{0}); forward_weight_vector.begin(), forward_weight_vector.end(), EdgeWeight{0});
// The edge.distance is the whole edge weight, which includes the turn cost. // The edge.weight is the whole edge weight, which includes the turn cost.
// The turn cost is the edge.distance minus the sum of the individual road // The turn cost is the edge.weight minus the sum of the individual road
// segment weights. This might not be 100% accurate, because some // segment weights. This might not be 100% accurate, because some
// intersections include stop signs, traffic signals and other penalties, // intersections include stop signs, traffic signals and other penalties,
// but at this stage, we can't divide those out, so we just treat the whole // but at this stage, we can't divide those out, so we just treat the whole
// lot as the "turn cost" that we'll stick on the map. // lot as the "turn cost" that we'll stick on the map.
const auto turn_cost = data.distance - sum_node_weight; const auto turn_cost = data.weight - sum_node_weight;
// Find the three nodes that make up the turn movement) // Find the three nodes that make up the turn movement)
const auto node_from = first_geometry.size() > 1 const auto node_from = first_geometry.size() > 1