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

Add type traits to disable plugins for specific algorithms

Browse Source
This commit is contained in:
Patrick Niklaus 2017-02-25 02:22:17 +00:00 committed by Patrick Niklaus
parent 436b34ffea
commit 922e155763
13 changed files with 179 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
include/engine/algorithm.hpp
View File

@ -1,6 +1,8 @@
#ifndef OSRM_ENGINE_ALGORITHM_HPP
#define OSRM_ENGINE_ALGORITHM_HPP
#include <type_traits>
namespace osrm
{
namespace engine
@ -9,27 +11,29 @@ namespace algorithm
{
// Contraction Hiearchy
struct CH;
struct CH final {};
// Contraction Hiearchy with core
struct CoreCH final {};
}
namespace algorithm_trais
{
template <typename AlgorithmT> struct HasAlternativeRouting final
{
template <template <typename A> class FacadeT> bool operator()(const FacadeT<AlgorithmT> &)
{
return false;
}
};
template <> struct HasAlternativeRouting<algorithm::CH> final
{
template <template <typename A> class FacadeT>
bool operator()(const FacadeT<algorithm::CH> &facade)
{
return facade.GetCoreSize() == 0;
}
};
template <typename AlgorithmT> struct HasAlternativePathSearch final : std::false_type {};
template <typename AlgorithmT> struct HasShortestPathSearch final : std::false_type {};
template <typename AlgorithmT> struct HasDirectShortestPathSearch final : std::false_type {};
template <typename AlgorithmT> struct HasMapMatching final : std::false_type {};
template <typename AlgorithmT> struct HasManyToManySearch final : std::false_type {};
template <typename AlgorithmT> struct HasGetTileTurns final : std::false_type {};
template <> struct HasAlternativePathSearch<algorithm::CH> final : std::true_type {};
template <> struct HasShortestPathSearch<algorithm::CH> final : std::true_type {};
template <> struct HasDirectShortestPathSearch<algorithm::CH> final : std::true_type {};
template <> struct HasMapMatching<algorithm::CH> final : std::true_type {};
template <> struct HasManyToManySearch<algorithm::CH> final : std::true_type {};
template <> struct HasGetTileTurns<algorithm::CH> final : std::true_type {};
}
}
}

63
include/engine/routing_algorithms.hpp
View File

@ -19,17 +19,17 @@ namespace engine
class RoutingAlgorithmsInterface
{
public:
virtual InternalRouteResult AlternativeRouting(const PhantomNodes &phantom_node_pair) const = 0;
virtual InternalRouteResult AlternativePathSearch(const PhantomNodes &phantom_node_pair) const = 0;
virtual InternalRouteResult
ShortestRouting(const std::vector<PhantomNodes> &phantom_node_pair,
ShortestPathSearch(const std::vector<PhantomNodes> &phantom_node_pair,
const boost::optional<bool> continue_straight_at_waypoint) const = 0;
virtual InternalRouteResult
DirectShortestPathRouting(const std::vector<PhantomNodes> &phantom_node_pair) const = 0;
DirectShortestPathSearch(const std::vector<PhantomNodes> &phantom_node_pair) const = 0;
virtual std::vector<EdgeWeight>
ManyToManyRouting(const std::vector<PhantomNode> &phantom_nodes,
ManyToManySearch(const std::vector<PhantomNode> &phantom_nodes,
const std::vector<std::size_t> &source_indices,
const std::vector<std::size_t> &target_indices) const = 0;
@ -40,12 +40,24 @@ class RoutingAlgorithmsInterface
const std::vector<boost::optional<double>> &trace_gps_precision) const = 0;
virtual std::vector<routing_algorithms::TurnData>
TileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
GetTileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
const std::vector<std::size_t> &sorted_edge_indexes) const = 0;
virtual bool HasAlternativeRouting() const = 0;
virtual bool HasAlternativePathSearch() const = 0;
virtual bool HasShortestPathSearch() const = 0;
virtual bool HasDirectShortestPathSearch() const = 0;
virtual bool HasMapMatching() const = 0;
virtual bool HasManyToManySearch() const = 0;
virtual bool HasGetTileTurns() const = 0;
};
namespace detail
{
struct NotImplementedException : public std::runtime_error {};
}
// Short-lived object passed to each plugin in request to wrap routing algorithms
template <typename AlgorithmT> class RoutingAlgorithms final : public RoutingAlgorithmsInterface
{
@ -57,27 +69,27 @@ template <typename AlgorithmT> class RoutingAlgorithms final : public RoutingAlg
}
InternalRouteResult
AlternativeRouting(const PhantomNodes &phantom_node_pair) const final override
AlternativePathSearch(const PhantomNodes &phantom_node_pair) const final override
{
return routing_algorithms::alternativePathSearch(heaps, facade, phantom_node_pair);
}
InternalRouteResult
ShortestRouting(const std::vector<PhantomNodes> &phantom_node_pair,
ShortestPathSearch(const std::vector<PhantomNodes> &phantom_node_pair,
const boost::optional<bool> continue_straight_at_waypoint) const final override
{
return routing_algorithms::shortestPathSearch(
heaps, facade, phantom_node_pair, continue_straight_at_waypoint);
}
InternalRouteResult DirectShortestPathRouting(
InternalRouteResult DirectShortestPathSearch(
const std::vector<PhantomNodes> &phantom_node_pair) const final override
{
return routing_algorithms::directShortestPathSearch(heaps, facade, phantom_node_pair);
}
std::vector<EdgeWeight>
ManyToManyRouting(const std::vector<PhantomNode> &phantom_nodes,
ManyToManySearch(const std::vector<PhantomNode> &phantom_nodes,
const std::vector<std::size_t> &source_indices,
const std::vector<std::size_t> &target_indices) const final override
{
@ -100,15 +112,40 @@ template <typename AlgorithmT> class RoutingAlgorithms final : public RoutingAlg
}
std::vector<routing_algorithms::TurnData>
TileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
GetTileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
const std::vector<std::size_t> &sorted_edge_indexes) const final override
{
return routing_algorithms::getTileTurns(facade, edges, sorted_edge_indexes);
}
bool HasAlternativeRouting() const final override
bool HasAlternativePathSearch() const final override
{
return algorithm_trais::HasAlternativeRouting<AlgorithmT>()(facade);
return algorithm_trais::HasAlternativePathSearch<AlgorithmT>::value;
}
bool HasShortestPathSearch() const final override
{
return algorithm_trais::HasShortestPathSearch<AlgorithmT>::value;
}
bool HasDirectShortestPathSearch() const final override
{
return algorithm_trais::HasDirectShortestPathSearch<AlgorithmT>::value;
}
bool HasMapMatching() const final override
{
return algorithm_trais::HasMapMatching<AlgorithmT>::value;
}
bool HasManyToManySearch() const final override
{
return algorithm_trais::HasManyToManySearch<AlgorithmT>::value;
}
bool HasGetTileTurns() const final override
{
return algorithm_trais::HasGetTileTurns<AlgorithmT>::value;
}
private:

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

@ -7,6 +7,8 @@
#include "engine/algorithm.hpp"
#include "engine/search_engine_data.hpp"
#include "util/exception.hpp"
namespace osrm
{
namespace engine
@ -14,6 +16,16 @@ namespace engine
namespace routing_algorithms
{
template <typename AlgorithmT>
InternalRouteResult
alternativePathSearch(SearchEngineData &,
const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &,
const PhantomNodes &)
{
throw util::exception(std::string("alternativePathSearch is not implemented for ") +
typeid(AlgorithmT).name());
}
InternalRouteResult
alternativePathSearch(SearchEngineData &search_engine_data,
const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,

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

@ -15,6 +15,16 @@ namespace engine
namespace routing_algorithms
{
template <typename AlgorithmT>
InternalRouteResult
directShortestPathSearch(SearchEngineData &,
const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &,
const std::vector<PhantomNodes> &)
{
throw util::exception(std::string("directShortestPathSearch is not implemented for ") +
typeid(AlgorithmT).name());
}
/// This is a striped down version of the general shortest path algorithm.
/// The general algorithm always computes two queries for each leg. This is only
/// necessary in case of vias, where the directions of the start node is constrainted

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

@ -17,6 +17,18 @@ namespace engine
namespace routing_algorithms
{
template <typename AlgorithmT>
std::vector<EdgeWeight>
manyToManySearch(SearchEngineData &,
const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &,
const std::vector<PhantomNode> &,
const std::vector<std::size_t> &,
const std::vector<std::size_t> &)
{
throw util::exception(std::string("manyToManySearch is not implemented for ") +
typeid(AlgorithmT).name());
}
std::vector<EdgeWeight>
manyToManySearch(SearchEngineData &engine_working_data,
const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,

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

@ -20,6 +20,18 @@ using CandidateLists = std::vector<CandidateList>;
using SubMatchingList = std::vector<map_matching::SubMatching>;
static const constexpr double DEFAULT_GPS_PRECISION = 5;
template <typename AlgorithmT>
SubMatchingList mapMatching(SearchEngineData &,
const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &,
const CandidateLists &,
const std::vector<util::Coordinate> &,
const std::vector<unsigned> &,
const std::vector<boost::optional<double>> &)
{
throw util::exception(std::string("mapMatching is not implemented for ") +
typeid(AlgorithmT).name());
}
SubMatchingList
mapMatching(SearchEngineData &engine_working_data,
const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,

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

@ -13,6 +13,17 @@ namespace engine
namespace routing_algorithms
{
template <typename AlgorithmT>
InternalRouteResult
shortestPathSearch(SearchEngineData &,
const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &,
const std::vector<PhantomNodes> &,
const boost::optional<bool>)
{
throw util::exception(std::string("shortestPathSearch is not implemented for ") +
typeid(AlgorithmT).name());
}
InternalRouteResult
shortestPathSearch(SearchEngineData &engine_working_data,
const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,

10
include/engine/routing_algorithms/tile_turns.hpp
View File

@ -27,6 +27,16 @@ struct TurnData final
using RTreeLeaf = datafacade::BaseDataFacade::RTreeLeaf;
template <typename AlgorithmT>
std::vector<TurnData>
getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &,
const std::vector<RTreeLeaf> &,
const std::vector<std::size_t> &)
{
throw util::exception(std::string("getTileTurns is not implemented for ") +
typeid(AlgorithmT).name());
}
std::vector<TurnData>
getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<algorithm::CH> &facade,
const std::vector<RTreeLeaf> &edges,

7
src/engine/plugins/match.cpp
View File

@ -113,6 +113,11 @@ Status MatchPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
const api::MatchParameters &parameters,
util::json::Object &json_result) const
{
if (!algorithms.HasMapMatching())
{
return Error("NotImplemented", "Map matching is not implemented for the chosen search algorithm.", json_result);
}
BOOST_ASSERT(parameters.IsValid());
// enforce maximum number of locations for performance reasons
@ -209,7 +214,7 @@ Status MatchPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
// bi-directional
// phantom nodes for possible uturns
sub_routes[index] =
algorithms.ShortestRouting(sub_routes[index].segment_end_coordinates, {false});
algorithms.ShortestPathSearch(sub_routes[index].segment_end_coordinates, {false});
BOOST_ASSERT(sub_routes[index].shortest_path_length != INVALID_EDGE_WEIGHT);
}

7
src/engine/plugins/table.cpp
View File

@ -33,6 +33,11 @@ Status TablePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
const api::TableParameters &params,
util::json::Object &result) const
{
if (!algorithms.HasManyToManySearch())
{
return Error("NotImplemented", "Many to many search is not implemented for the chosen search algorithm.", result);
}
BOOST_ASSERT(params.IsValid());
if (!CheckAllCoordinates(params.coordinates))
@ -62,7 +67,7 @@ Status TablePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
auto snapped_phantoms = SnapPhantomNodes(GetPhantomNodes(facade, params));
auto result_table =
algorithms.ManyToManyRouting(snapped_phantoms, params.sources, params.destinations);
algorithms.ManyToManySearch(snapped_phantoms, params.sources, params.destinations);
if (result_table.empty())
{

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

@ -756,9 +756,9 @@ Status TilePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataF
// If we're zooming into 16 or higher, include turn data. Why? Because turns make the map
// really cramped, so we don't bother including the data for tiles that span a large area.
if (parameters.z >= MIN_ZOOM_FOR_TURNS)
if (parameters.z >= MIN_ZOOM_FOR_TURNS && algorithms.HasGetTileTurns())
{
turns = algorithms.TileTurns(edges, edge_index);
turns = algorithms.GetTileTurns(edges, edge_index);
}
encodeVectorTile(

13
src/engine/plugins/trip.cpp
View File

@ -85,7 +85,7 @@ InternalRouteResult TripPlugin::ComputeRoute(const RoutingAlgorithmsInterface &a
BOOST_ASSERT(min_route.segment_end_coordinates.size() == trip.size() - 1);
}
min_route = algorithms.ShortestRouting(min_route.segment_end_coordinates, {false});
min_route = algorithms.ShortestPathSearch(min_route.segment_end_coordinates, {false});
BOOST_ASSERT_MSG(min_route.shortest_path_length < INVALID_EDGE_WEIGHT, "unroutable route");
return min_route;
}
@ -147,6 +147,15 @@ Status TripPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataF
const api::TripParameters &parameters,
util::json::Object &json_result) const
{
if (!algorithms.HasShortestPathSearch())
{
return Error("NotImplemented", "Shortest path search is not implemented for the chosen search algorithm.", json_result);
}
if (!algorithms.HasManyToManySearch())
{
return Error("NotImplemented", "Many to many search is not implemented for the chosen search algorithm.", json_result);
}
BOOST_ASSERT(parameters.IsValid());
const auto number_of_locations = parameters.coordinates.size();
@ -201,7 +210,7 @@ Status TripPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataF
// compute the duration table of all phantom nodes
auto result_table = util::DistTableWrapper<EdgeWeight>(
algorithms.ManyToManyRouting(snapped_phantoms, {}, {}), number_of_locations);
algorithms.ManyToManySearch(snapped_phantoms, {}, {}), number_of_locations);
if (result_table.size() == 0)
{

27
src/engine/plugins/viaroute.cpp
View File

@ -34,6 +34,16 @@ ViaRoutePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataFaca
{
BOOST_ASSERT(route_parameters.IsValid());
if (!algorithms.HasShortestPathSearch() && route_parameters.coordinates.size() > 2)
{
return Error("NotImplemented", "Shortest path search is not implemented for the chosen search algorithm. Only two coordinates supported.", json_result);
}
if (!algorithms.HasDirectShortestPathSearch() && !algorithms.HasShortestPathSearch())
{
return Error("NotImplemented", "Direct shortest path search is not implemented for the chosen search algorithm.", json_result);
}
if (max_locations_viaroute > 0 &&
(static_cast<int>(route_parameters.coordinates.size()) > max_locations_viaroute))
{
@ -85,20 +95,17 @@ ViaRoutePlugin::HandleRequest(const datafacade::ContiguousInternalMemoryDataFaca
};
util::for_each_pair(snapped_phantoms, build_phantom_pairs);
if (1 == raw_route.segment_end_coordinates.size())
if (1 == raw_route.segment_end_coordinates.size() && algorithms.HasAlternativePathSearch() && route_parameters.alternatives)
{
if (route_parameters.alternatives && algorithms.HasAlternativeRouting())
{
raw_route = algorithms.AlternativeRouting(raw_route.segment_end_coordinates.front());
}
else
{
raw_route = algorithms.DirectShortestPathRouting(raw_route.segment_end_coordinates);
}
raw_route = algorithms.AlternativePathSearch(raw_route.segment_end_coordinates.front());
}
else if (1 == raw_route.segment_end_coordinates.size() && algorithms.HasDirectShortestPathSearch())
{
raw_route = algorithms.DirectShortestPathSearch(raw_route.segment_end_coordinates);
}
else
{
raw_route = algorithms.ShortestRouting(raw_route.segment_end_coordinates,
raw_route = algorithms.ShortestPathSearch(raw_route.segment_end_coordinates,
route_parameters.continue_straight);
}