Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity
master
osrm-backend/include/engine/datafacade/algorithm_datafacade.hpp

111 lines
3.8 KiB
C++
Raw Permalink Normal View History

Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
#ifndef OSRM_ENGINE_DATAFACADE_ALGORITHM_DATAFACADE_HPP
#define OSRM_ENGINE_DATAFACADE_ALGORITHM_DATAFACADE_HPP
#include "contractor/query_edge.hpp"
Remove weight and duration from customizer::EdgeBasedGraphEdgeData
2018-04-23 00:01:09 -04:00
#include "customizer/edge_based_graph.hpp"
Add edge-based graph loading in MLD facade
2017-03-06 17:00:11 -05:00
#include "extractor/edge_based_edge.hpp"
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
#include "engine/algorithm.hpp"
Moved MultiLevelPartition and CellStorage to partition namespace
2017-03-04 13:54:06 -05:00
Rename namespace partition to partitioner Rename module partition to partitioner. This cultivates naming used in existing modules like extractor, customizer, etc. - noun vs verb (word partition is both though).
2018-02-01 10:47:43 -05:00
#include "partitioner/cell_storage.hpp"
#include "partitioner/multi_level_partition.hpp"
Moved MultiLevelPartition and CellStorage to partition namespace
2017-03-04 13:54:06 -05:00
Implement exclude flags on CH using shared core The core is fully contracted for each exclude flag and stored in a merged graph data structure.
2017-08-20 19:24:05 -04:00
#include "util/filtered_graph.hpp"
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
#include "util/integer_range.hpp"
Use nested namespace It's a mechanical change to modernize the code base
2022-12-11 04:10:26 -05:00
namespace osrm::engine::datafacade
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
{
itroduce ADL via algorithm specific ch, corech and mld namespaces
2017-03-31 06:52:04 -04:00
// Namespace local aliases for algorithms
using CH = routing_algorithms::ch::Algorithm;
using MLD = routing_algorithms::mld::Algorithm;
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
template <typename AlgorithmT> class AlgorithmDataFacade;
itroduce ADL via algorithm specific ch, corech and mld namespaces
2017-03-31 06:52:04 -04:00
template <> class AlgorithmDataFacade<CH>
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
{
public:
using EdgeData = contractor::QueryEdge::EdgeData;
Implement exclude flags on CH using shared core The core is fully contracted for each exclude flag and stored in a merged graph data structure.
2017-08-20 19:24:05 -04:00
using EdgeRange = util::filtered_range<EdgeID, util::vector_view<bool>>;
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
Update CI to use clang-tidy 14 (#6353)
2022-08-31 17:39:47 -04:00
virtual ~AlgorithmDataFacade() = default;
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
// search graph access
virtual unsigned GetNumberOfNodes() const = 0;
virtual unsigned GetNumberOfEdges() const = 0;
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual unsigned GetOutDegree(const NodeID edge_based_node_id) const = 0;
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual NodeID GetTarget(const EdgeID edge_based_edge_id) const = 0;
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual const EdgeData &GetEdgeData(const EdgeID edge_based_edge_id) const = 0;
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual EdgeRange GetAdjacentEdgeRange(const NodeID edge_based_node_id) const = 0;
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
// searches for a specific edge
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual EdgeID FindEdge(const NodeID edge_based_node_from,
const NodeID edge_based_node_to) const = 0;
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual EdgeID FindEdgeInEitherDirection(const NodeID edge_based_node_from,
const NodeID edge_based_node_to) const = 0;
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual EdgeID FindEdgeIndicateIfReverse(const NodeID edge_based_node_from,
const NodeID edge_based_node_to,
bool &result) const = 0;
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual EdgeID FindSmallestEdge(const NodeID edge_based_node_from,
const NodeID edge_based_node_to,
Avoid copy of std::function-based callback in path unpacking (#6895) * Avoid copy of std::function-based callback in path unpacking * Fix formatting * Update CHANGELOG.md
2024-05-23 12:51:51 -04:00
const std::function<bool(const EdgeData &)> &filter) const = 0;
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
};
Pull everthing in the facades
2017-03-01 17:55:18 -05:00
itroduce ADL via algorithm specific ch, corech and mld namespaces
2017-03-31 06:52:04 -04:00
template <> class AlgorithmDataFacade<MLD>
Pull everthing in the facades
2017-03-01 17:55:18 -05:00
{
public:
Remove weight and duration from customizer::EdgeBasedGraphEdgeData
2018-04-23 00:01:09 -04:00
using EdgeData = customizer::EdgeBasedGraphEdgeData;
Implement exclude flags on CH using shared core The core is fully contracted for each exclude flag and stored in a merged graph data structure.
2017-08-20 19:24:05 -04:00
using EdgeRange = util::range<EdgeID>;
Add edge-based graph loading in MLD facade
2017-03-06 17:00:11 -05:00
Update CI to use clang-tidy 14 (#6353)
2022-08-31 17:39:47 -04:00
virtual ~AlgorithmDataFacade() = default;
Add edge-based graph loading in MLD facade
2017-03-06 17:00:11 -05:00
// search graph access
virtual unsigned GetNumberOfNodes() const = 0;
Use ArrayStorage for boundary nodes to optimize MLD For the MLD algorithm we can partition the NodeID range into boundary and non-boundary nodes. Since there are only we boundary nodes we can use the ArrayStorage for those yielding much faster query times.
2018-04-08 12:37:08 -04:00
virtual unsigned GetMaxBorderNodeID() const = 0;
Add edge-based graph loading in MLD facade
2017-03-06 17:00:11 -05:00
virtual unsigned GetNumberOfEdges() const = 0;
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual unsigned GetOutDegree(const NodeID edge_based_node_id) const = 0;
Add edge-based graph loading in MLD facade
2017-03-06 17:00:11 -05:00
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual EdgeRange GetAdjacentEdgeRange(const NodeID edge_based_node_id) const = 0;
Always read .osrm.enw file in updater
2018-04-22 02:34:31 -04:00
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual EdgeWeight GetNodeWeight(const NodeID edge_based_node_id) const = 0;
Always read .osrm.enw file in updater
2018-04-22 02:34:31 -04:00
Make edge metrics strongly typed (#6421) This change takes the existing typedefs for weight, duration and distance, and makes them proper types, using the existing Alias functionality. Primarily this is to prevent bugs where the metrics are switched, but it also adds additional documentation. For example, it now makes it clear (despite the naming of variables) that most of the trip algorithm is running on the duration metric. I've not made any changes to the casts performed between metrics and numeric types, they now just more explicit.
2022-10-28 10:16:12 -04:00
virtual EdgeDuration
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
GetNodeDuration(const NodeID edge_based_node_id) const = 0; // TODO: to be removed
Always read .osrm.enw file in updater
2018-04-22 02:34:31 -04:00
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual EdgeDistance GetNodeDistance(const NodeID edge_based_node_id) const = 0;
Replace dynamic distance calculation for table plugin with pre-calculated distances on shortcuts, avoiding unpacking cost. Adds approx 10% to total data size. Speeds up large table requests by 2 orders of magnitude. Co-authored-by: Kajari Ghosh <ghoshkaj@gmail.com>
2018-10-30 00:47:49 -04:00
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual bool IsForwardEdge(EdgeID edge_based_edge_id) const = 0;
Remove weight and duration from customizer::EdgeBasedGraphEdgeData
2018-04-23 00:01:09 -04:00
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual bool IsBackwardEdge(EdgeID edge_based_edge_id) const = 0;
Remove weight and duration from customizer::EdgeBasedGraphEdgeData
2018-04-23 00:01:09 -04:00
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual NodeID GetTarget(const EdgeID edge_based_edge_id) const = 0;
Add edge-based graph loading in MLD facade
2017-03-06 17:00:11 -05:00
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual const EdgeData &GetEdgeData(const EdgeID edge_based_edge_id) const = 0;
Add edge-based graph loading in MLD facade
2017-03-06 17:00:11 -05:00
Rename namespace partition to partitioner Rename module partition to partitioner. This cultivates naming used in existing modules like extractor, customizer, etc. - noun vs verb (word partition is both though).
2018-02-01 10:47:43 -05:00
virtual const partitioner::MultiLevelPartitionView &GetMultiLevelPartition() const = 0;
Pull everthing in the facades
2017-03-01 17:55:18 -05:00
Rename namespace partition to partitioner Rename module partition to partitioner. This cultivates naming used in existing modules like extractor, customizer, etc. - noun vs verb (word partition is both though).
2018-02-01 10:47:43 -05:00
virtual const partitioner::CellStorageView &GetCellStorage() const = 0;
Change edge_id to from_clique_arc in MultiLayerDijkstraHeapData
2017-03-15 09:36:41 -04:00
Refactor cell weights and durations to own file and allow for multiple metrics
2017-07-24 20:05:15 -04:00
virtual const customizer::CellMetricView &GetCellMetric() const = 0;
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual EdgeRange GetBorderEdgeRange(const LevelID level,
const NodeID edge_based_node_id) const = 0;
Adds a special graph for MLD with effcient boundary scan This graph enables efficient boundary edge scans at each level. Currenly this needs about |V|*|L| bytes of storage. We can optimize this when the highest boundary nodes ID is << |V|.
2017-03-06 22:59:28 -05:00
Change edge_id to from_clique_arc in MultiLayerDijkstraHeapData
2017-03-15 09:36:41 -04:00
// searches for a specific edge
Clarify identifier types used in data facade The data facade interface contains numerous methods for looking up datapoints by identifiers. Many of the parameters use the NodeID or EdgeID types. However, these two identifier types are used for representing three different contexts: 1. Node-based graph edges and nodes 2. Edge-based graph edges and nodes 3. Packed geometries Consider the use of identifier parameters in these examples: --- GetWeightPenaltyForEdgeID(const EdgeID id) <- edge-based edge GetUncompressedForwardWeights(const EdgeID id) <- packed geometry IsLeftHandDriving(const NodeID id) <- edge-based node GetBearingClass(const NodeID node) <- node-based node --- This mixing of contexts within the same interface makes it difficult to understand the relationships and dependencies between the OSRM datasets. For 1. and 2. we continue to use the NodeID and EdgeID types, but change the interface parameter names to identify them as edge-based or node-based graph properties. For 3. we define a new type definition, PackedGeometryID. These changes are to aid with readability. A next step would be to strongly type these definitions, leveraging the Alias template already used for OSM identifiers.
2021-06-01 15:48:12 -04:00
virtual EdgeID FindEdge(const NodeID edge_based_node_from,
const NodeID edge_based_node_to) const = 0;
Pull everthing in the facades
2017-03-01 17:55:18 -05:00
};
Fix formatting
2022-12-20 12:00:11 -05:00
} // namespace osrm::engine::datafacade
Port OSRM, Engine and Datafacades to be algorithm aware
2017-01-09 15:40:33 -05:00
#endif
Reference in New Issue Copy Permalink