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

wip

Browse Source
This commit is contained in:
Siarhei Fedartsou 2024-05-26 12:19:58 +02:00
parent 49cf294d2f
commit 8b34d5b40c
4 changed files with 205 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -359,7 +359,7 @@ if(ENABLE_CONAN)
KEEP_RPATHS
NO_OUTPUT_DIRS
OPTIONS boost:filesystem_version=3 # https://stackoverflow.com/questions/73392648/error-with-boost-filesystem-version-in-cmake
onetbb:shared=${TBB_SHARED}
# onetbb:shared=${TBB_SHARED}
boost:without_stacktrace=True # Apple Silicon cross-compilation fails without it
BUILD missing
)

17
include/engine/routing_algorithms/routing_base_ch.hpp
View File

@ -471,6 +471,23 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
const PhantomNode &target_phantom,
EdgeWeight duration_upper_bound = INVALID_EDGE_WEIGHT);
inline double getNetworkDistanceOld(SearchEngineData<Algorithm> &engine_working_data,
const DataFacade<ch::Algorithm> &facade,
SearchEngineData<Algorithm>::QueryHeap &forward_heap,
SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
const PhantomNode &source_phantom,
const PhantomNode &target_phantom,
EdgeWeight duration_upper_bound = INVALID_EDGE_WEIGHT)
{
return getNetworkDistance(engine_working_data,
facade,
forward_heap,
reverse_heap,
source_phantom,
target_phantom,
duration_upper_bound);
}
template <typename EdgeMetric>
std::tuple<EdgeMetric, EdgeDistance> getLoopMetric(const DataFacade<Algorithm> &facade, NodeID node)
{

138
include/engine/routing_algorithms/routing_base_mld.hpp
View File

@ -705,42 +705,134 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
{
reverse_heap.Clear();
// forward_heap.Clear();
if (forward_heap.empty()) {
if (source_phantom.IsValidForwardSource())
{
forward_heap.Insert(source_phantom.forward_segment_id.id,
EdgeWeight{0} - source_phantom.GetForwardWeightPlusOffset(),
{source_phantom.forward_segment_id.id,
false,
EdgeDistance{0} - source_phantom.GetForwardDistance()});
}
// if (forward_heap.Empty())
// {
// if (source_phantom.IsValidForwardSource())
// {
// forward_heap.Insert(source_phantom.forward_segment_id.id,
// EdgeWeight{0} - source_phantom.GetForwardWeightPlusOffset(),
// {source_phantom.forward_segment_id.id,
// false,
// EdgeDistance{0} - source_phantom.GetForwardDistance()});
// }
if (source_phantom.IsValidReverseSource())
// if (source_phantom.IsValidReverseSource())
// {
// forward_heap.Insert(source_phantom.reverse_segment_id.id,
// EdgeWeight{0} - source_phantom.GetReverseWeightPlusOffset(),
// {source_phantom.reverse_segment_id.id,
// false,
// EdgeDistance{0} - source_phantom.GetReverseDistance()});
// }
// } else {
// const auto node =
// forward_heap.GetHeapNodeIfWasInserted(target_phantom.forward_segment_id.id); if (node) {
// std::cerr << "Found " << target_phantom.forward_segment_id.id << " in forward_heap "
// << node->data.distance << std::endl;
// }
// }
if (!forward_heap.Empty())
{
if (target_phantom.IsValidForwardTarget() && !target_phantom.IsValidReverseTarget())
{
forward_heap.Insert(source_phantom.reverse_segment_id.id,
EdgeWeight{0} - source_phantom.GetReverseWeightPlusOffset(),
{source_phantom.reverse_segment_id.id,
false,
EdgeDistance{0} - source_phantom.GetReverseDistance()});
if (const auto node =
forward_heap.GetHeapNodeIfWasInserted(target_phantom.forward_segment_id.id))
{
return from_alias<double>(node->data.distance);
}
}
// if (target_phantom.IsValidReverseTarget()) {
// if (const auto node =
// forward_heap.GetHeapNodeIfWasInserted(target_phantom.reverse_segment_id.id)) {
// return from_alias<double>(node->data.distance);
// }
// }
}
forward_heap.Clear();
if (source_phantom.IsValidForwardSource())
{
forward_heap.Insert(source_phantom.forward_segment_id.id,
EdgeWeight{0},
{source_phantom.forward_segment_id.id, false, EdgeDistance{0}});
}
if (source_phantom.IsValidReverseSource())
{
forward_heap.Insert(source_phantom.reverse_segment_id.id,
EdgeWeight{0},
{source_phantom.reverse_segment_id.id, false, EdgeDistance{0}});
}
if (target_phantom.IsValidForwardTarget())
{
reverse_heap.Insert(
target_phantom.forward_segment_id.id,
target_phantom.GetForwardWeightPlusOffset(),
{target_phantom.forward_segment_id.id, false, target_phantom.GetForwardDistance()});
reverse_heap.Insert(target_phantom.forward_segment_id.id,
EdgeWeight{0},
{target_phantom.forward_segment_id.id, false, EdgeDistance{0}});
}
if (target_phantom.IsValidReverseTarget())
{
reverse_heap.Insert(
target_phantom.reverse_segment_id.id,
target_phantom.GetReverseWeightPlusOffset(),
{target_phantom.reverse_segment_id.id, false, target_phantom.GetReverseDistance()});
reverse_heap.Insert(target_phantom.reverse_segment_id.id,
EdgeWeight{0},
{target_phantom.reverse_segment_id.id, false, EdgeDistance{0}});
}
const PhantomEndpoints endpoints{source_phantom, target_phantom};
auto distance = searchDistance(
engine_working_data, facade, forward_heap, reverse_heap, {}, weight_upper_bound, endpoints);
if (distance == INVALID_EDGE_DISTANCE)
{
return std::numeric_limits<double>::max();
}
return from_alias<double>(distance);
}
template <typename Algorithm>
double
getNetworkDistanceOld(SearchEngineData<Algorithm> &engine_working_data,
const DataFacade<Algorithm> &facade,
typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap,
typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &reverse_heap,
const PhantomNode &source_phantom,
const PhantomNode &target_phantom,
EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
{
reverse_heap.Clear();
forward_heap.Clear();
if (source_phantom.IsValidForwardSource())
{
forward_heap.Insert(source_phantom.forward_segment_id.id,
EdgeWeight{0},
{source_phantom.forward_segment_id.id, false, EdgeDistance{0}});
}
if (source_phantom.IsValidReverseSource())
{
forward_heap.Insert(source_phantom.reverse_segment_id.id,
EdgeWeight{0},
{source_phantom.reverse_segment_id.id, false, EdgeDistance{0}});
}
if (target_phantom.IsValidForwardTarget())
{
reverse_heap.Insert(target_phantom.forward_segment_id.id,
EdgeWeight{0},
{target_phantom.forward_segment_id.id, false, EdgeDistance{0}});
}
if (target_phantom.IsValidReverseTarget())
{
reverse_heap.Insert(target_phantom.reverse_segment_id.id,
EdgeWeight{0},
{target_phantom.reverse_segment_id.id, false, EdgeDistance{0}});
}
const PhantomEndpoints endpoints{source_phantom, target_phantom};

72
src/engine/routing_algorithms/map_matching.cpp
View File

@ -217,6 +217,78 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
const EdgeWeight weight_upper_bound = to_alias<EdgeWeight>(
((haversine_distance + max_distance_delta) / 4.) * facade.GetWeightMultiplier());
std::vector<double> old_distances;
for (const auto s : util::irange<std::size_t>(0UL, prev_viterbi.size()))
{
if (prev_pruned[s])
{
continue;
}
forward_heap.Clear();
for (const auto s_prime : util::irange<std::size_t>(0UL, current_viterbi.size()))
{
const double emission_pr = emission_log_probabilities[t][s_prime];
double new_value = prev_viterbi[s] + emission_pr;
if (current_viterbi[s_prime] > new_value)
{
continue;
}
double network_distance =
getNetworkDistanceOld(engine_working_data,
facade,
forward_heap,
reverse_heap,
prev_unbroken_timestamps_list[s].phantom_node,
current_timestamps_list[s_prime].phantom_node,
weight_upper_bound);
old_distances.push_back(network_distance);
}
}
std::vector<double> new_distances;
for (const auto s : util::irange<std::size_t>(0UL, prev_viterbi.size()))
{
if (prev_pruned[s])
{
continue;
}
forward_heap.Clear();
for (const auto s_prime : util::irange<std::size_t>(0UL, current_viterbi.size()))
{
const double emission_pr = emission_log_probabilities[t][s_prime];
double new_value = prev_viterbi[s] + emission_pr;
if (current_viterbi[s_prime] > new_value)
{
continue;
}
double network_distance =
getNetworkDistance(engine_working_data,
facade,
forward_heap,
reverse_heap,
prev_unbroken_timestamps_list[s].phantom_node,
current_timestamps_list[s_prime].phantom_node,
weight_upper_bound);
new_distances.push_back(network_distance);
}
}
BOOST_ASSERT(old_distances.size() == new_distances.size());
for (std::size_t i = 0; i < old_distances.size(); i++)
{
if (std::abs(old_distances[i] - new_distances[i]) > 1e-3)
{
std::cout << "Old: " << old_distances[i] << " New: " << new_distances[i]
<< std::endl;
}
}
// compute d_t for this timestamp and the next one
for (const auto s : util::irange<std::size_t>(0UL, prev_viterbi.size()))
{