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
Download Patch File Download Diff File Expand all files Collapse all files
include/engine/datafacade/internal_datafacade.hpp
-1
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_rev_weight_list;
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<std::string, false>::vector m_datasource_names;
util::ShM<std::uint32_t, false>::vector m_lane_description_offsets;
include/engine/edge_unpacker.hpp
+1 -1
View File
@@ -82,7 +82,7 @@ inline void UnpackCHPath(const DataFacadeT &facade,
BOOST_ASSERT_MSG(smaller_edge_id != SPECIAL_EDGEID, "Invalid 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");
// If the edge is a shortcut, we need to add the two halfs to the stack.
include/engine/routing_algorithms/alternative_path.hpp
+65 -67
View File
@@ -79,7 +79,7 @@ class AlternativeRouting final
QueryHeap &forward_heap2 = *(engine_working_data.forward_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;
const EdgeWeight min_edge_offset =
std::min(phantom_node_pair.source_phantom.forward_segment_id.enabled
@@ -132,7 +132,7 @@ class AlternativeRouting final
forward_heap1,
reverse_heap1,
&middle_node,
&upper_bound_to_shortest_path_distance,
&upper_bound_to_shortest_path_weight,
via_node_candidate_list,
forward_search_space,
min_edge_offset);
@@ -143,14 +143,14 @@ class AlternativeRouting final
forward_heap1,
reverse_heap1,
&middle_node,
&upper_bound_to_shortest_path_distance,
&upper_bound_to_shortest_path_weight,
via_node_candidate_list,
reverse_search_space,
min_edge_offset);
}
}
if (INVALID_EDGE_WEIGHT == upper_bound_to_shortest_path_distance)
if (INVALID_EDGE_WEIGHT == upper_bound_to_shortest_path_weight)
{
return;
}
@@ -163,7 +163,7 @@ class AlternativeRouting final
std::vector<NodeID> packed_reverse_path;
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);
if (path_is_a_loop)
{
@@ -257,14 +257,13 @@ class AlternativeRouting final
const int approximated_sharing = fwd_sharing + rev_sharing;
const int approximated_length = forward_heap1.GetKey(node) + reverse_heap1.GetKey(node);
const bool length_passes =
(approximated_length <
upper_bound_to_shortest_path_distance * (1 + VIAPATH_EPSILON));
(approximated_length < upper_bound_to_shortest_path_weight * (1 + VIAPATH_EPSILON));
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 =
(approximated_length - approximated_sharing) <
((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)
{
@@ -293,9 +292,9 @@ class AlternativeRouting final
packed_shortest_path,
min_edge_offset);
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 &&
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);
}
@@ -313,7 +312,7 @@ class AlternativeRouting final
forward_heap2,
reverse_heap2,
candidate,
upper_bound_to_shortest_path_distance,
upper_bound_to_shortest_path_weight,
&length_of_via_path,
&s_v_middle,
&v_t_middle,
@@ -326,7 +325,7 @@ class AlternativeRouting final
}
// 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());
raw_route_data.unpacked_path_segments.resize(1);
@@ -345,7 +344,7 @@ class AlternativeRouting final
phantom_node_pair,
// -- unpacked output
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)
@@ -488,7 +487,7 @@ class AlternativeRouting final
{
EdgeID edgeID = facade.FindEdgeInEitherDirection(packed_s_v_path[current_node],
packed_s_v_path[current_node + 1]);
*sharing_of_via_path += facade.GetEdgeData(edgeID).distance;
*sharing_of_via_path += facade.GetEdgeData(edgeID).weight;
}
else
{
@@ -521,7 +520,7 @@ class AlternativeRouting final
EdgeID selected_edge =
facade.FindEdgeInEitherDirection(partially_unpacked_via_path[current_node],
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
@@ -536,7 +535,7 @@ class AlternativeRouting final
{
EdgeID edgeID = facade.FindEdgeInEitherDirection(
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
{
@@ -568,7 +567,7 @@ class AlternativeRouting final
EdgeID edgeID = facade.FindEdgeInEitherDirection(
partially_unpacked_via_path[via_path_index - 1],
partially_unpacked_via_path[via_path_index]);
*sharing_of_via_path += facade.GetEdgeData(edgeID).distance;
*sharing_of_via_path += facade.GetEdgeData(edgeID).weight;
}
else
{
@@ -606,7 +605,7 @@ class AlternativeRouting final
// packed_alternate_path[aindex] << "," << packed_alternate_path[aindex+1] << ")";
// EdgeID edgeID = facade->FindEdgeInEitherDirection(packed_alternate_path[aindex],
// packed_alternate_path[aindex+1]);
// sharing += facade->GetEdgeData(edgeID).distance;
// sharing += facade->GetEdgeData(edgeID).weight;
// ++aindex;
// }
@@ -618,7 +617,7 @@ class AlternativeRouting final
// packed_shortest_path[bindex-1]) ) {
// EdgeID edgeID = facade->FindEdgeInEitherDirection(packed_alternate_path[aindex],
// packed_alternate_path[aindex-1]);
// sharing += facade->GetEdgeData(edgeID).distance;
// sharing += facade->GetEdgeData(edgeID).weight;
// --aindex; --bindex;
// }
// return sharing;
@@ -630,7 +629,7 @@ class AlternativeRouting final
QueryHeap &heap1,
QueryHeap &heap2,
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<SearchSpaceEdge> &search_space,
const EdgeWeight min_edge_offset) const
@@ -639,16 +638,16 @@ class AlternativeRouting final
QueryHeap &reverse_heap = (is_forward_directed ? heap2 : heap1);
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;
// util::SimpleLogger().Write() << (is_forward_directed ? "[fwd] " : "[rev] ") << "settled
// edge ("
// << parentnode << "," << node << "), dist: " << distance;
// << parentnode << "," << node << "), dist: " << weight;
const int scaled_distance =
static_cast<int>((distance + min_edge_offset) / (1. + VIAPATH_EPSILON));
if ((INVALID_EDGE_WEIGHT != *upper_bound_to_shortest_path_distance) &&
(scaled_distance > *upper_bound_to_shortest_path_distance))
const int scaled_weight =
static_cast<int>((weight + min_edge_offset) / (1. + VIAPATH_EPSILON));
if ((INVALID_EDGE_WEIGHT != *upper_bound_to_shortest_path_weight) &&
(scaled_weight > *upper_bound_to_shortest_path_weight))
{
forward_heap.DeleteAll();
return;
@@ -659,31 +658,31 @@ class AlternativeRouting final
if (reverse_heap.WasInserted(node))
{
search_space_intersection.emplace_back(node);
const int new_distance = reverse_heap.GetKey(node) + distance;
if (new_distance < *upper_bound_to_shortest_path_distance)
const int new_weight = reverse_heap.GetKey(node) + weight;
if (new_weight < *upper_bound_to_shortest_path_weight)
{
if (new_distance >= 0)
if (new_weight >= 0)
{
*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
// << " at
// distance " << new_distance;
// weight " << new_weight;
// } else {
// util::SimpleLogger().Write() << "discarded middle_node " << *middle_node
// << "
// at distance " << new_distance;
// at weight " << new_weight;
}
else
{
// check whether there is a loop present at the node
const auto loop_distance = super::GetLoopWeight(facade, node);
const int new_distance_with_loop = new_distance + loop_distance;
if (loop_distance != INVALID_EDGE_WEIGHT &&
new_distance_with_loop <= *upper_bound_to_shortest_path_distance)
const auto loop_weight = super::GetLoopWeight(facade, node);
const int new_weight_with_loop = new_weight + loop_weight;
if (loop_weight != INVALID_EDGE_WEIGHT &&
new_weight_with_loop <= *upper_bound_to_shortest_path_weight)
{
*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);
if (edge_is_forward_directed)
{
const NodeID to = facade.GetTarget(edge);
const int edge_weight = data.distance;
const int edge_weight = data.weight;
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
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
else if (to_distance < forward_heap.GetKey(to))
// Found a shorter Path -> Update weight
else if (to_weight < forward_heap.GetKey(to))
{
// new parent
forward_heap.GetData(to).parent = node;
// decreased distance
forward_heap.DecreaseKey(to, to_distance);
// decreased weight
forward_heap.DecreaseKey(to, to_weight);
}
}
}
@@ -806,7 +804,7 @@ class AlternativeRouting final
return false;
}
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;
// Traverse path s-->v
@@ -814,14 +812,14 @@ class AlternativeRouting final
{
const EdgeID current_edge_id =
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;
if ((length_of_current_edge + unpacked_until_distance) >= T_threshold)
const int length_of_current_edge = facade.GetEdgeData(current_edge_id).weight;
if ((length_of_current_edge + unpacked_until_weight) >= T_threshold)
{
unpack_stack.emplace(packed_s_v_path[i - 1], packed_s_v_path[i]);
}
else
{
unpacked_until_distance += length_of_current_edge;
unpacked_until_weight += length_of_current_edge;
s_P = packed_s_v_path[i - 1];
}
}
@@ -846,30 +844,30 @@ class AlternativeRouting final
const EdgeID second_segment_edge_id =
facade.FindEdgeInEitherDirection(via_path_middle_node_id, via_path_edge.second);
const int second_segment_length =
facade.GetEdgeData(second_segment_edge_id).distance;
facade.GetEdgeData(second_segment_edge_id).weight;
// attention: !unpacking in reverse!
// 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.
if (unpacked_until_distance + second_segment_length >= T_threshold)
// to stack, else push first segment to stack and add weight of second one.
if (unpacked_until_weight + second_segment_length >= T_threshold)
{
unpack_stack.emplace(via_path_middle_node_id, via_path_edge.second);
}
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);
}
}
else
{
// 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;
}
}
int t_test_path_length = unpacked_until_distance;
unpacked_until_distance = 0;
int t_test_path_length = unpacked_until_weight;
unpacked_until_weight = 0;
// Traverse path s-->v
BOOST_ASSERT(!packed_v_t_path.empty());
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 =
facade.FindEdgeInEitherDirection(packed_v_t_path[i], packed_v_t_path[i + 1]);
int length_of_current_edge = facade.GetEdgeData(edgeID).distance;
if (length_of_current_edge + unpacked_until_distance >= T_threshold)
int length_of_current_edge = facade.GetEdgeData(edgeID).weight;
if (length_of_current_edge + unpacked_until_weight >= T_threshold)
{
unpack_stack.emplace(packed_v_t_path[i], packed_v_t_path[i + 1]);
}
else
{
unpacked_until_distance += length_of_current_edge;
unpacked_until_weight += length_of_current_edge;
t_P = packed_v_t_path[i + 1];
}
}
@@ -908,29 +906,29 @@ class AlternativeRouting final
const NodeID middleOfViaPath = current_edge_data.id;
EdgeID edgeIDOfFirstSegment =
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
// stack, else push second segment to stack and add distance of first one.
if (unpacked_until_distance + lengthOfFirstSegment >= T_threshold)
// stack, else push second segment to stack and add weight of first one.
if (unpacked_until_weight + lengthOfFirstSegment >= T_threshold)
{
unpack_stack.emplace(via_path_edge.first, middleOfViaPath);
}
else
{
unpacked_until_distance += lengthOfFirstSegment;
unpacked_until_weight += lengthOfFirstSegment;
unpack_stack.emplace(middleOfViaPath, via_path_edge.second);
}
}
else
{
// 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_test_path_length += unpacked_until_distance;
// Run actual T-Test query and compare if distances equal.
t_test_path_length += unpacked_until_weight;
// Run actual T-Test query and compare if weight equal.
engine_working_data.InitializeOrClearThirdThreadLocalStorage(facade.GetNumberOfNodes());
QueryHeap &forward_heap3 = *engine_working_data.forward_heap_3;
include/engine/routing_algorithms/direct_shortest_path.hpp
+6 -6
View File
@@ -43,7 +43,7 @@ class DirectShortestPathRouting final
const std::vector<PhantomNodes> &phantom_nodes_vector,
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(),
"Direct Shortest Path Query only accepts a single source and target pair. "
"Multiple ones have been specified.");
@@ -87,7 +87,7 @@ class DirectShortestPathRouting final
target_phantom.reverse_segment_id.id);
}
int distance = INVALID_EDGE_WEIGHT;
int weight = INVALID_EDGE_WEIGHT;
std::vector<NodeID> packed_leg;
const bool constexpr DO_NOT_FORCE_LOOPS =
@@ -107,7 +107,7 @@ class DirectShortestPathRouting final
reverse_heap,
forward_core_heap,
reverse_core_heap,
distance,
weight,
packed_leg,
DO_NOT_FORCE_LOOPS,
DO_NOT_FORCE_LOOPS);
@@ -117,14 +117,14 @@ class DirectShortestPathRouting final
super::Search(facade,
forward_heap,
reverse_heap,
distance,
weight,
packed_leg,
DO_NOT_FORCE_LOOPS,
DO_NOT_FORCE_LOOPS);
}
// 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.alternative_path_length = INVALID_EDGE_WEIGHT;
@@ -133,7 +133,7 @@ class DirectShortestPathRouting final
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.source_traversed_in_reverse.push_back(
(packed_leg.front() != phantom_node_pair.source_phantom.forward_segment_id.id));
include/engine/routing_algorithms/many_to_many.hpp
+33 -33
View File
@@ -29,10 +29,10 @@ class ManyToManyRouting final
struct NodeBucket
{
unsigned target_id; // essentially a row in the distance matrix
EdgeWeight distance;
NodeBucket(const unsigned target_id, const EdgeWeight distance)
: target_id(target_id), distance(distance)
unsigned target_id; // essentially a row in the weight matrix
EdgeWeight weight;
NodeBucket(const unsigned target_id, const EdgeWeight weight)
: target_id(target_id), weight(weight)
{
}
};
@@ -68,7 +68,7 @@ class ManyToManyRouting final
unsigned column_idx = 0;
const auto search_target_phantom = [&](const PhantomNode &phantom) {
query_heap.Clear();
// insert target(s) at distance 0
// insert target(s) at weight 0
if (phantom.forward_segment_id.enabled)
{
@@ -95,7 +95,7 @@ class ManyToManyRouting final
unsigned row_idx = 0;
const auto search_source_phantom = [&](const PhantomNode &phantom) {
query_heap.Clear();
// insert target(s) at distance 0
// insert target(s) at weight 0
if (phantom.forward_segment_id.enabled)
{
@@ -166,7 +166,7 @@ class ManyToManyRouting final
std::vector<EdgeWeight> &result_table) const
{
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
const auto bucket_iterator = search_space_with_buckets.find(node);
@@ -178,30 +178,30 @@ class ManyToManyRouting final
{
// get target id from bucket entry
const unsigned column_idx = current_bucket.target_id;
const int target_distance = current_bucket.distance;
auto &current_distance = result_table[row_idx * number_of_targets + column_idx];
// check if new distance is better
const EdgeWeight new_distance = source_distance + target_distance;
if (new_distance < 0)
const int target_weight = current_bucket.weight;
auto &current_weight = result_table[row_idx * number_of_targets + column_idx];
// check if new weight is better
const EdgeWeight new_weight = source_weight + target_weight;
if (new_weight < 0)
{
const EdgeWeight loop_weight = super::GetLoopWeight(facade, node);
const int new_distance_with_loop = new_distance + loop_weight;
if (loop_weight != INVALID_EDGE_WEIGHT && new_distance_with_loop >= 0)
const int new_weight_with_loop = new_weight + loop_weight;
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;
}
RelaxOutgoingEdges<true>(facade, node, source_distance, query_heap);
RelaxOutgoingEdges<true>(facade, node, source_weight, query_heap);
}
void BackwardRoutingStep(const DataFacadeT &facade,
@@ -210,23 +210,23 @@ class ManyToManyRouting final
SearchSpaceWithBuckets &search_space_with_buckets) const
{
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
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;
}
RelaxOutgoingEdges<false>(facade, node, target_distance, query_heap);
RelaxOutgoingEdges<false>(facade, node, target_weight, query_heap);
}
template <bool forward_direction>
inline void RelaxOutgoingEdges(const DataFacadeT &facade,
const NodeID node,
const EdgeWeight distance,
const EdgeWeight weight,
QueryHeap &query_heap) const
{
for (auto edge : facade.GetAdjacentEdgeRange(node))
@@ -236,22 +236,22 @@ class ManyToManyRouting final
if (direction_flag)
{
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");
const int to_distance = distance + edge_weight;
const int to_weight = weight + edge_weight;
// New Node discovered -> Add to Heap + Node Info Storage
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
else if (to_distance < query_heap.GetKey(to))
// Found a shorter Path -> Update weight
else if (to_weight < query_heap.GetKey(to))
{
// new parent
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>
inline bool StallAtNode(const DataFacadeT &facade,
const NodeID node,
const EdgeWeight distance,
const EdgeWeight weight,
QueryHeap &query_heap) const
{
for (auto edge : facade.GetAdjacentEdgeRange(node))
@@ -271,11 +271,11 @@ class ManyToManyRouting final
if (reverse_flag)
{
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");
if (query_heap.WasInserted(to))
{
if (query_heap.GetKey(to) + edge_weight < distance)
if (query_heap.GetKey(to) + edge_weight < weight)
{
return true;
}
include/engine/routing_algorithms/routing_base.hpp
+43 -44
View File
@@ -76,19 +76,19 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
const bool force_loop_reverse) const
{
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))
{
const std::int32_t new_distance = reverse_heap.GetKey(node) + distance;
if (new_distance < upper_bound)
const std::int32_t new_weight = reverse_heap.GetKey(node) + weight;
if (new_weight < upper_bound)
{
// if loops are forced, they are so at the source
if ((force_loop_forward && forward_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
// 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
for (const auto edge : facade.GetAdjacentEdgeRange(node))
@@ -101,12 +101,12 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
const NodeID to = facade.GetTarget(edge);
if (to == node)
{
const EdgeWeight edge_weight = data.distance;
const std::int32_t loop_distance = new_distance + edge_weight;
if (loop_distance >= 0 && loop_distance < upper_bound)
const EdgeWeight edge_weight = data.weight;
const std::int32_t loop_weight = new_weight + edge_weight;
if (loop_weight >= 0 && loop_weight < upper_bound)
{
middle_node_id = node;
upper_bound = loop_distance;
upper_bound = loop_weight;
}
}
}
@@ -114,18 +114,18 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
}
else
{
BOOST_ASSERT(new_distance >= 0);
BOOST_ASSERT(new_weight >= 0);
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
BOOST_ASSERT(min_edge_offset <= 0);
if (distance + min_edge_offset > upper_bound)
if (weight + min_edge_offset > upper_bound)
{
forward_heap.DeleteAll();
return;
@@ -141,13 +141,13 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
if (reverse_flag)
{
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");
if (forward_heap.WasInserted(to))
{
if (forward_heap.GetKey(to) + edge_weight < distance)
if (forward_heap.GetKey(to) + edge_weight < weight)
{
return;
}
@@ -162,24 +162,23 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
bool forward_directionFlag = (forward_direction ? data.forward : data.backward);
if (forward_directionFlag)
{
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");
const int to_distance = distance + edge_weight;
const int to_weight = weight + edge_weight;
// New Node discovered -> Add to Heap + Node Info Storage
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
else if (to_distance < forward_heap.GetKey(to))
// Found a shorter Path -> Update weight
else if (to_weight < forward_heap.GetKey(to))
{
// new parent
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);
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().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().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.
// 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
// the last node.
if (unpacked_path.size() > 1)
@@ -483,14 +482,14 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
void Search(const DataFacadeT &facade,
SearchEngineData::QueryHeap &forward_heap,
SearchEngineData::QueryHeap &reverse_heap,
std::int32_t &distance,
std::int32_t &weight,
std::vector<NodeID> &packed_leg,
const bool force_loop_forward,
const bool force_loop_reverse,
const int duration_upper_bound = INVALID_EDGE_WEIGHT) const
{
NodeID middle = SPECIAL_NODEID;
distance = duration_upper_bound;
weight = duration_upper_bound;
// get offset to account for offsets on phantom nodes on compressed edges
const auto min_edge_offset = std::min(0, forward_heap.MinKey());
@@ -508,7 +507,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
forward_heap,
reverse_heap,
middle,
distance,
weight,
min_edge_offset,
true,
STALLING_ENABLED,
@@ -521,7 +520,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
reverse_heap,
forward_heap,
middle,
distance,
weight,
min_edge_offset,
false,
STALLING_ENABLED,
@@ -531,18 +530,18 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
}
// 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;
}
// 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");
// 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
packed_leg.push_back(middle);
@@ -568,14 +567,14 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
SearchEngineData::QueryHeap &reverse_heap,
SearchEngineData::QueryHeap &forward_core_heap,
SearchEngineData::QueryHeap &reverse_core_heap,
int &distance,
int &weight,
std::vector<NodeID> &packed_leg,
const bool force_loop_forward,
const bool force_loop_reverse,
int duration_upper_bound = INVALID_EDGE_WEIGHT) const
{
NodeID middle = SPECIAL_NODEID;
distance = duration_upper_bound;
weight = duration_upper_bound;
using CoreEntryPoint = std::tuple<NodeID, EdgeWeight, NodeID>;
std::vector<CoreEntryPoint> forward_entry_points;
@@ -604,7 +603,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
forward_heap,
reverse_heap,
middle,
distance,
weight,
min_edge_offset,
true,
STALLING_ENABLED,
@@ -626,7 +625,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
reverse_heap,
forward_heap,
middle,
distance,
weight,
min_edge_offset,
false,
STALLING_ENABLED,
@@ -673,13 +672,13 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
// run two-target Dijkstra routing step on core with termination criterion
const constexpr bool STALLING_DISABLED = false;
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,
forward_core_heap,
reverse_core_heap,
middle,
distance,
weight,
min_core_edge_offset,
true,
STALLING_DISABLED,
@@ -690,7 +689,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
reverse_core_heap,
forward_core_heap,
middle,
distance,
weight,
min_core_edge_offset,
false,
STALLING_DISABLED,
@@ -699,20 +698,20 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
}
// 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;
}
// 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");
// we need to unpack sub path from core heaps
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
BOOST_ASSERT(forward_core_heap.GetData(middle).parent == middle &&
@@ -734,7 +733,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
}
else
{
if (distance != forward_heap.GetKey(middle) + reverse_heap.GetKey(middle))
if (weight != forward_heap.GetKey(middle) + reverse_heap.GetKey(middle))
{
// self loop
BOOST_ASSERT(forward_heap.GetData(middle).parent == middle &&
include/engine/routing_algorithms/shortest_path.hpp
+48 -48
View File
@@ -48,9 +48,9 @@ class ShortestPathRouting final
const bool search_to_reverse_node,
const PhantomNode &source_phantom,
const PhantomNode &target_phantom,
const int total_distance_to_forward,
const int total_distance_to_reverse,
int &new_total_distance,
const int total_weight_to_forward,
const int total_weight_to_reverse,
int &new_total_weight,
std::vector<NodeID> &leg_packed_path) const
{
forward_heap.Clear();
@@ -102,7 +102,7 @@ class ShortestPathRouting final
reverse_heap,
forward_core_heap,
reverse_core_heap,
new_total_distance,
new_total_weight,
leg_packed_path,
needs_loop_forwad,
needs_loop_backwards);
@@ -112,7 +112,7 @@ class ShortestPathRouting final
super::Search(facade,
forward_heap,
reverse_heap,
new_total_distance,
new_total_weight,
leg_packed_path,
needs_loop_forwad,
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
// 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
if (new_total_distance != INVALID_EDGE_WEIGHT)
new_total_distance += std::min(total_distance_to_forward, total_distance_to_reverse);
if (new_total_weight != INVALID_EDGE_WEIGHT)
new_total_weight += std::min(total_weight_to_forward, total_weight_to_reverse);
}
// searches shortest path between:
@@ -138,10 +138,10 @@ class ShortestPathRouting final
const bool search_to_reverse_node,
const PhantomNode &source_phantom,
const PhantomNode &target_phantom,
const int total_distance_to_forward,
const int total_distance_to_reverse,
int &new_total_distance_to_forward,
int &new_total_distance_to_reverse,
const int total_weight_to_forward,
const int total_weight_to_reverse,
int &new_total_weight_to_forward,
int &new_total_weight_to_reverse,
std::vector<NodeID> &leg_packed_path_forward,
std::vector<NodeID> &leg_packed_path_reverse) const
{
@@ -156,14 +156,14 @@ class ShortestPathRouting final
if (search_from_forward_node)
{
forward_heap.Insert(source_phantom.forward_segment_id.id,
total_distance_to_forward -
total_weight_to_forward -
source_phantom.GetForwardWeightPlusOffset(),
source_phantom.forward_segment_id.id);
}
if (search_from_reverse_node)
{
forward_heap.Insert(source_phantom.reverse_segment_id.id,
total_distance_to_reverse -
total_weight_to_reverse -
source_phantom.GetReverseWeightPlusOffset(),
source_phantom.reverse_segment_id.id);
}
@@ -181,7 +181,7 @@ class ShortestPathRouting final
reverse_heap,
forward_core_heap,
reverse_core_heap,
new_total_distance_to_forward,
new_total_weight_to_forward,
leg_packed_path_forward,
super::NeedsLoopForward(source_phantom, target_phantom),
DO_NOT_FORCE_LOOP);
@@ -191,7 +191,7 @@ class ShortestPathRouting final
super::Search(facade,
forward_heap,
reverse_heap,
new_total_distance_to_forward,
new_total_weight_to_forward,
leg_packed_path_forward,
super::NeedsLoopForward(source_phantom, target_phantom),
DO_NOT_FORCE_LOOP);
@@ -208,14 +208,14 @@ class ShortestPathRouting final
if (search_from_forward_node)
{
forward_heap.Insert(source_phantom.forward_segment_id.id,
total_distance_to_forward -
total_weight_to_forward -
source_phantom.GetForwardWeightPlusOffset(),
source_phantom.forward_segment_id.id);
}
if (search_from_reverse_node)
{
forward_heap.Insert(source_phantom.reverse_segment_id.id,
total_distance_to_reverse -
total_weight_to_reverse -
source_phantom.GetReverseWeightPlusOffset(),
source_phantom.reverse_segment_id.id);
}
@@ -232,7 +232,7 @@ class ShortestPathRouting final
reverse_heap,
forward_core_heap,
reverse_core_heap,
new_total_distance_to_reverse,
new_total_weight_to_reverse,
leg_packed_path_reverse,
DO_NOT_FORCE_LOOP,
super::NeedsLoopBackwards(source_phantom, target_phantom));
@@ -242,7 +242,7 @@ class ShortestPathRouting final
super::Search(facade,
forward_heap,
reverse_heap,
new_total_distance_to_reverse,
new_total_weight_to_reverse,
leg_packed_path_reverse,
DO_NOT_FORCE_LOOP,
super::NeedsLoopBackwards(source_phantom, target_phantom));
@@ -298,8 +298,8 @@ class ShortestPathRouting final
QueryHeap &forward_core_heap = *(engine_working_data.forward_heap_2);
QueryHeap &reverse_core_heap = *(engine_working_data.reverse_heap_2);
int total_distance_to_forward = 0;
int total_distance_to_reverse = 0;
int total_weight_to_forward = 0;
int total_weight_to_reverse = 0;
bool search_from_forward_node =
phantom_nodes_vector.front().source_phantom.forward_segment_id.enabled;
bool search_from_reverse_node =
@@ -318,8 +318,8 @@ class ShortestPathRouting final
// a list of vias
for (const auto &phantom_node_pair : phantom_nodes_vector)
{
int new_total_distance_to_forward = INVALID_EDGE_WEIGHT;
int new_total_distance_to_reverse = INVALID_EDGE_WEIGHT;
int new_total_weight_to_forward = 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_reverse;
@@ -350,22 +350,22 @@ class ShortestPathRouting final
search_to_reverse_node,
source_phantom,
target_phantom,
total_distance_to_forward,
total_distance_to_reverse,
new_total_distance_to_forward,
total_weight_to_forward,
total_weight_to_reverse,
new_total_weight_to_forward,
packed_leg_to_forward);
// if only the reverse node is valid (e.g. when using the match plugin) we
// actually need to move
if (!target_phantom.forward_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);
new_total_distance_to_forward = INVALID_EDGE_WEIGHT;
new_total_weight_to_forward = INVALID_EDGE_WEIGHT;
}
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;
}
}
@@ -382,18 +382,18 @@ class ShortestPathRouting final
search_to_reverse_node,
source_phantom,
target_phantom,
total_distance_to_forward,
total_distance_to_reverse,
new_total_distance_to_forward,
new_total_distance_to_reverse,
total_weight_to_forward,
total_weight_to_reverse,
new_total_weight_to_forward,
new_total_weight_to_reverse,
packed_leg_to_forward,
packed_leg_to_reverse);
}
}
// No path found for both target nodes?
if ((INVALID_EDGE_WEIGHT == new_total_distance_to_forward) &&
(INVALID_EDGE_WEIGHT == new_total_distance_to_reverse))
if ((INVALID_EDGE_WEIGHT == new_total_weight_to_forward) &&
(INVALID_EDGE_WEIGHT == new_total_weight_to_reverse))
{
raw_route_data.shortest_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)
{
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;
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;
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;
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;
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);
@@ -464,7 +464,7 @@ class ShortestPathRouting final
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);
@@ -484,17 +484,17 @@ class ShortestPathRouting final
prev_packed_leg_to_forward = std::move(packed_leg_to_forward);
prev_packed_leg_to_reverse = std::move(packed_leg_to_reverse);
total_distance_to_forward = new_total_distance_to_forward;
total_distance_to_reverse = new_total_distance_to_reverse;
total_weight_to_forward = new_total_weight_to_forward;
total_weight_to_reverse = new_total_weight_to_reverse;
++current_leg;
}
BOOST_ASSERT(total_distance_to_forward != INVALID_EDGE_WEIGHT ||
total_distance_to_reverse != INVALID_EDGE_WEIGHT);
BOOST_ASSERT(total_weight_to_forward != INVALID_EDGE_WEIGHT ||
total_weight_to_reverse != INVALID_EDGE_WEIGHT);
// 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
packed_leg_to_reverse_begin.push_back(total_packed_path_to_reverse.size());
@@ -504,7 +504,7 @@ class ShortestPathRouting final
phantom_nodes_vector,
total_packed_path_to_reverse,
packed_leg_to_reverse_begin,
total_distance_to_reverse,
total_weight_to_reverse,
raw_route_data);
}
else
@@ -517,7 +517,7 @@ class ShortestPathRouting final
phantom_nodes_vector,
total_packed_path_to_forward,
packed_leg_to_forward_begin,
total_distance_to_forward,
total_weight_to_forward,
raw_route_data);
}
}