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

Renamed EdgeBasedNode to EdgeBasedNodeSegment

Browse Source
This commit is contained in:
Michael Krasnyk 2017-05-16 19:22:41 +02:00 committed by Patrick Niklaus
parent 1a7cd785f2
commit 5e2e1d4c96
10 changed files with 69 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/contractor/contractor.hpp
View File

@ -31,7 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "contractor/contractor_config.hpp" #include "contractor/contractor_config.hpp"
#include "contractor/query_edge.hpp" #include "contractor/query_edge.hpp"
#include "extractor/edge_based_edge.hpp" #include "extractor/edge_based_edge.hpp"
#include "extractor/edge_based_node.hpp" #include "extractor/edge_based_node_segment.hpp"
#include "util/deallocating_vector.hpp" #include "util/deallocating_vector.hpp"
#include "util/typedefs.hpp" #include "util/typedefs.hpp"

4
include/engine/datafacade/datafacade_base.hpp
View File

@ -4,7 +4,7 @@
// Exposes all data access interfaces to the algorithms via base class ptr // Exposes all data access interfaces to the algorithms via base class ptr
#include "contractor/query_edge.hpp" #include "contractor/query_edge.hpp"
#include "extractor/edge_based_node.hpp" #include "extractor/edge_based_node_segment.hpp"
#include "extractor/external_memory_node.hpp" #include "extractor/external_memory_node.hpp"
#include "extractor/guidance/turn_instruction.hpp" #include "extractor/guidance/turn_instruction.hpp"
#include "extractor/guidance/turn_lane_types.hpp" #include "extractor/guidance/turn_lane_types.hpp"
@ -40,7 +40,7 @@ using StringView = util::StringView;
class BaseDataFacade class BaseDataFacade
{ {
public: public:
using RTreeLeaf = extractor::EdgeBasedNode; using RTreeLeaf = extractor::EdgeBasedNodeSegment;
BaseDataFacade() {} BaseDataFacade() {}
virtual ~BaseDataFacade() {} virtual ~BaseDataFacade() {}

10
include/extractor/edge_based_graph_factory.hpp
View File

@ -5,7 +5,7 @@
#include "extractor/compressed_edge_container.hpp" #include "extractor/compressed_edge_container.hpp"
#include "extractor/edge_based_edge.hpp" #include "extractor/edge_based_edge.hpp"
#include "extractor/edge_based_node.hpp" #include "extractor/edge_based_node_segment.hpp"
#include "extractor/extraction_turn.hpp" #include "extractor/extraction_turn.hpp"
#include "extractor/guidance/turn_analysis.hpp" #include "extractor/guidance/turn_analysis.hpp"
#include "extractor/guidance/turn_instruction.hpp" #include "extractor/guidance/turn_instruction.hpp"
@ -93,8 +93,8 @@ class EdgeBasedGraphFactory
// The following get access functions destroy the content in the factory // The following get access functions destroy the content in the factory
void GetEdgeBasedEdges(util::DeallocatingVector<EdgeBasedEdge> &edges); void GetEdgeBasedEdges(util::DeallocatingVector<EdgeBasedEdge> &edges);
void GetEdgeBasedNodes(EdgeBasedNodeDataContainer &ebg_node_data_container); void GetEdgeBasedNodes(EdgeBasedNodeDataContainer &data_container);
void GetNodeBasedEdges(std::vector<EdgeBasedNode> &nodes); void GetEdgeBasedNodeSegments(std::vector<EdgeBasedNodeSegment> &nodes);
void GetStartPointMarkers(std::vector<bool> &node_is_startpoint); void GetStartPointMarkers(std::vector<bool> &node_is_startpoint);
void GetEdgeBasedNodeWeights(std::vector<EdgeWeight> &output_node_weights); void GetEdgeBasedNodeWeights(std::vector<EdgeWeight> &output_node_weights);
@ -129,8 +129,8 @@ class EdgeBasedGraphFactory
std::vector<EdgeWeight> m_edge_based_node_weights; std::vector<EdgeWeight> m_edge_based_node_weights;
//! list of edge based nodes (compressed segments) //! list of edge based nodes (compressed segments)
std::vector<EdgeBasedNode> m_edge_based_node_list; std::vector<EdgeBasedNodeSegment> m_edge_based_node_segments;
EdgeBasedNodeDataContainer m_ebg_node_data_container; EdgeBasedNodeDataContainer m_edge_based_node_container;
util::DeallocatingVector<EdgeBasedEdge> m_edge_based_edge_list; util::DeallocatingVector<EdgeBasedEdge> m_edge_based_edge_list;
EdgeID m_max_edge_id; EdgeID m_max_edge_id;

12
include/extractor/edge_based_node.hpp → include/extractor/edge_based_node_segment.hpp
View File

@ -1,5 +1,5 @@
#ifndef EDGE_BASED_NODE_HPP #ifndef OSRM_EXTRACT_EDGE_BASED_NODE_SEGMENT_HPP
#define EDGE_BASED_NODE_HPP #define OSRM_EXTRACT_EDGE_BASED_NODE_SEGMENT_HPP
#include "extractor/travel_mode.hpp" #include "extractor/travel_mode.hpp"
#include "util/typedefs.hpp" #include "util/typedefs.hpp"
@ -17,16 +17,16 @@ namespace extractor
/// This is what util::StaticRTree serialized and stores on disk /// This is what util::StaticRTree serialized and stores on disk
/// It is generated in EdgeBasedGraphFactory. /// It is generated in EdgeBasedGraphFactory.
struct EdgeBasedNode struct EdgeBasedNodeSegment
{ {
EdgeBasedNode() EdgeBasedNodeSegment()
: forward_segment_id{SPECIAL_SEGMENTID, false}, : forward_segment_id{SPECIAL_SEGMENTID, false},
reverse_segment_id{SPECIAL_SEGMENTID, false}, u(SPECIAL_NODEID), v(SPECIAL_NODEID), reverse_segment_id{SPECIAL_SEGMENTID, false}, u(SPECIAL_NODEID), v(SPECIAL_NODEID),
fwd_segment_position(std::numeric_limits<unsigned short>::max()) fwd_segment_position(std::numeric_limits<unsigned short>::max())
{ {
} }
explicit EdgeBasedNode(const SegmentID forward_segment_id_, explicit EdgeBasedNodeSegment(const SegmentID forward_segment_id_,
const SegmentID reverse_segment_id_, const SegmentID reverse_segment_id_,
NodeID u, NodeID u,
NodeID v, NodeID v,
@ -46,4 +46,4 @@ struct EdgeBasedNode
} }
} }
#endif // EDGE_BASED_NODE_HPP #endif // OSRM_EXTRACT_EDGE_BASED_NODE_SEGMENT_HPP

6
include/extractor/extractor.hpp
View File

@ -63,8 +63,8 @@ class Extractor
BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment, BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
std::vector<util::Coordinate> &coordinates, std::vector<util::Coordinate> &coordinates,
extractor::PackedOSMIDs &osm_node_ids, extractor::PackedOSMIDs &osm_node_ids,
EdgeBasedNodeDataContainer &ebg_node_data_container, EdgeBasedNodeDataContainer &edge_based_nodes_container,
std::vector<EdgeBasedNode> &node_based_edge_list, std::vector<EdgeBasedNodeSegment> &edge_based_node_segments,
std::vector<bool> &node_is_startpoint, std::vector<bool> &node_is_startpoint,
std::vector<EdgeWeight> &edge_based_node_weights, std::vector<EdgeWeight> &edge_based_node_weights,
util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list, util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
@ -75,7 +75,7 @@ class Extractor
void FindComponents(unsigned max_edge_id, void FindComponents(unsigned max_edge_id,
const util::DeallocatingVector<EdgeBasedEdge> &edges, const util::DeallocatingVector<EdgeBasedEdge> &edges,
EdgeBasedNodeDataContainer &nodes) const; EdgeBasedNodeDataContainer &nodes) const;
void BuildRTree(std::vector<EdgeBasedNode> node_based_edge_list, void BuildRTree(std::vector<EdgeBasedNodeSegment> edge_based_node_segments,
std::vector<bool> node_is_startpoint, std::vector<bool> node_is_startpoint,
const std::vector<util::Coordinate> &coordinates); const std::vector<util::Coordinate> &coordinates);
std::shared_ptr<RestrictionMap> LoadRestrictionMap(); std::shared_ptr<RestrictionMap> LoadRestrictionMap();

2
include/extractor/node_data_container.hpp
View File

@ -70,7 +70,7 @@ template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl
// Used by EdgeBasedGraphFactory to fill data structure // Used by EdgeBasedGraphFactory to fill data structure
template <typename = std::enable_if<Ownership == storage::Ownership::Container>> template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
void SetData(NodeID node_id, ComponentID component_id) void SetComponentID(NodeID node_id, ComponentID component_id)
{ {
component_ids[node_id] = component_id; component_ids[node_id] = component_id;
} }

4
src/benchmarks/static_rtree.cpp
View File

@ -1,5 +1,5 @@
#include "util/static_rtree.hpp" #include "util/static_rtree.hpp"
#include "extractor/edge_based_node.hpp" #include "extractor/edge_based_node_segment.hpp"
#include "extractor/query_node.hpp" #include "extractor/query_node.hpp"
#include "mocks/mock_datafacade.hpp" #include "mocks/mock_datafacade.hpp"
#include "storage/io.hpp" #include "storage/io.hpp"
@ -26,7 +26,7 @@ constexpr int32_t WORLD_MAX_LAT = 90 * COORDINATE_PRECISION;
constexpr int32_t WORLD_MIN_LON = -180 * COORDINATE_PRECISION; constexpr int32_t WORLD_MIN_LON = -180 * COORDINATE_PRECISION;
constexpr int32_t WORLD_MAX_LON = 180 * COORDINATE_PRECISION; constexpr int32_t WORLD_MAX_LON = 180 * COORDINATE_PRECISION;
using RTreeLeaf = extractor::EdgeBasedNode; using RTreeLeaf = extractor::EdgeBasedNodeSegment;
using BenchStaticRTree = util::StaticRTree<RTreeLeaf, storage::Ownership::Container>; using BenchStaticRTree = util::StaticRTree<RTreeLeaf, storage::Ownership::Container>;
std::vector<util::Coordinate> loadCoordinates(const boost::filesystem::path &nodes_file) std::vector<util::Coordinate> loadCoordinates(const boost::filesystem::path &nodes_file)

23
src/extractor/edge_based_graph_factory.cpp
View File

@ -66,16 +66,16 @@ void EdgeBasedGraphFactory::GetEdgeBasedEdges(
swap(m_edge_based_edge_list, output_edge_list); swap(m_edge_based_edge_list, output_edge_list);
} }
void EdgeBasedGraphFactory::GetEdgeBasedNodes(EdgeBasedNodeDataContainer &ebg_node_data_container) void EdgeBasedGraphFactory::GetEdgeBasedNodes(EdgeBasedNodeDataContainer &data_container)
{ {
using std::swap; // Koenig swap using std::swap; // Koenig swap
swap(ebg_node_data_container, m_ebg_node_data_container); swap(data_container, m_edge_based_node_container);
} }
void EdgeBasedGraphFactory::GetNodeBasedEdges(std::vector<EdgeBasedNode> &nodes) void EdgeBasedGraphFactory::GetEdgeBasedNodeSegments(std::vector<EdgeBasedNodeSegment> &nodes)
{ {
using std::swap; // Koenig swap using std::swap; // Koenig swap
swap(nodes, m_edge_based_node_list); swap(nodes, m_edge_based_node_segments);
} }
void EdgeBasedGraphFactory::GetStartPointMarkers(std::vector<bool> &node_is_startpoint) void EdgeBasedGraphFactory::GetStartPointMarkers(std::vector<bool> &node_is_startpoint)
@ -142,13 +142,13 @@ NBGToEBG EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const N
// Add edge-based node data for forward and reverse nodes indexed by edge_id // Add edge-based node data for forward and reverse nodes indexed by edge_id
BOOST_ASSERT(forward_data.edge_id != SPECIAL_EDGEID); BOOST_ASSERT(forward_data.edge_id != SPECIAL_EDGEID);
m_ebg_node_data_container.SetData(forward_data.edge_id, m_edge_based_node_container.SetData(forward_data.edge_id,
GeometryID{packed_geometry_id, true}, GeometryID{packed_geometry_id, true},
forward_data.name_id, forward_data.name_id,
forward_data.travel_mode); forward_data.travel_mode);
if (reverse_data.edge_id != SPECIAL_EDGEID) if (reverse_data.edge_id != SPECIAL_EDGEID)
{ {
m_ebg_node_data_container.SetData(reverse_data.edge_id, m_edge_based_node_container.SetData(reverse_data.edge_id,
GeometryID{packed_geometry_id, false}, GeometryID{packed_geometry_id, false},
reverse_data.name_id, reverse_data.name_id,
reverse_data.travel_mode); reverse_data.travel_mode);
@ -165,7 +165,7 @@ NBGToEBG EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const N
BOOST_ASSERT(current_edge_target_coordinate_id != current_edge_source_coordinate_id); BOOST_ASSERT(current_edge_target_coordinate_id != current_edge_source_coordinate_id);
// build edges // build edges
m_edge_based_node_list.emplace_back(edge_id_to_segment_id(forward_data.edge_id), m_edge_based_node_segments.emplace_back(edge_id_to_segment_id(forward_data.edge_id),
edge_id_to_segment_id(reverse_data.edge_id), edge_id_to_segment_id(reverse_data.edge_id),
current_edge_source_coordinate_id, current_edge_source_coordinate_id,
current_edge_target_coordinate_id, current_edge_target_coordinate_id,
@ -257,7 +257,7 @@ std::vector<NBGToEBG> EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
std::vector<NBGToEBG> mapping; std::vector<NBGToEBG> mapping;
// Allocate memory for edge-based nodes // Allocate memory for edge-based nodes
m_ebg_node_data_container = EdgeBasedNodeDataContainer(m_max_edge_id + 1); m_edge_based_node_container = EdgeBasedNodeDataContainer(m_max_edge_id + 1);
util::Log() << "Generating edge expanded nodes ... "; util::Log() << "Generating edge expanded nodes ... ";
{ {
@ -300,10 +300,11 @@ std::vector<NBGToEBG> EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
} }
} }
BOOST_ASSERT(m_edge_based_node_list.size() == m_edge_based_node_is_startpoint.size()); BOOST_ASSERT(m_edge_based_node_segments.size() == m_edge_based_node_is_startpoint.size());
BOOST_ASSERT(m_max_edge_id + 1 == m_edge_based_node_weights.size()); BOOST_ASSERT(m_max_edge_id + 1 == m_edge_based_node_weights.size());
util::Log() << "Generated " << m_edge_based_node_list.size() << " nodes in edge-expanded graph"; util::Log() << "Generated " << (m_max_edge_id + 1) << " nodes and "
<< m_edge_based_node_segments.size() << " segments in edge-expanded graph";
return mapping; return mapping;
} }
@ -576,7 +577,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
files::writeTurnData(turn_data_filename, turn_data_container); files::writeTurnData(turn_data_filename, turn_data_container);
util::Log() << "Generated " << m_edge_based_node_list.size() << " edge based nodes"; util::Log() << "Generated " << m_edge_based_node_segments.size() << " edge based node segments";
util::Log() << "Node-based graph contains " << node_based_edge_counter << " edges"; util::Log() << "Node-based graph contains " << node_based_edge_counter << " edges";
util::Log() << "Edge-expanded graph ..."; util::Log() << "Edge-expanded graph ...";
util::Log() << " contains " << m_edge_based_edge_list.size() << " edges"; util::Log() << " contains " << m_edge_based_edge_list.size() << " edges";

38
src/extractor/extractor.cpp
View File

@ -131,7 +131,7 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
TIMER_START(expansion); TIMER_START(expansion);
EdgeBasedNodeDataContainer edge_based_nodes_container; EdgeBasedNodeDataContainer edge_based_nodes_container;
std::vector<EdgeBasedNode> node_based_edges_list; std::vector<EdgeBasedNodeSegment> edge_based_node_segments;
util::DeallocatingVector<EdgeBasedEdge> edge_based_edge_list; util::DeallocatingVector<EdgeBasedEdge> edge_based_edge_list;
std::vector<bool> node_is_startpoint; std::vector<bool> node_is_startpoint;
std::vector<EdgeWeight> edge_based_node_weights; std::vector<EdgeWeight> edge_based_node_weights;
@ -142,7 +142,7 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
coordinates, coordinates,
osm_node_ids, osm_node_ids,
edge_based_nodes_container, edge_based_nodes_container,
node_based_edges_list, edge_based_node_segments,
node_is_startpoint, node_is_startpoint,
edge_based_node_weights, edge_based_node_weights,
edge_based_edge_list, edge_based_edge_list,
@ -169,7 +169,7 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
util::Log() << "Building r-tree ..."; util::Log() << "Building r-tree ...";
TIMER_START(rtree); TIMER_START(rtree);
BuildRTree(std::move(node_based_edges_list), std::move(node_is_startpoint), coordinates); BuildRTree(std::move(edge_based_node_segments), std::move(node_is_startpoint), coordinates);
TIMER_STOP(rtree); TIMER_STOP(rtree);
@ -370,14 +370,12 @@ void Extractor::FindComponents(unsigned max_edge_id,
TarjanSCC<UncontractedGraph> component_search(uncontracted_graph); TarjanSCC<UncontractedGraph> component_search(uncontracted_graph);
component_search.Run(); component_search.Run();
stxxl::vector<ComponentID> component_ids;
component_ids.reserve(max_edge_id + 1);
for (NodeID node_id = 0; node_id <= max_edge_id; ++node_id) for (NodeID node_id = 0; node_id <= max_edge_id; ++node_id)
{ {
const auto forward_component = component_search.GetComponentID(node_id); const auto forward_component = component_search.GetComponentID(node_id);
const auto component_size = component_search.GetComponentSize(forward_component); const auto component_size = component_search.GetComponentSize(forward_component);
const auto is_tiny = component_size < config.small_component_size; const auto is_tiny = component_size < config.small_component_size;
input_nodes.SetData(node_id, {1 + forward_component, is_tiny}); input_nodes.SetComponentID(node_id, {1 + forward_component, is_tiny});
} }
} }
@ -421,8 +419,8 @@ std::pair<std::size_t, EdgeID>
Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment, Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
std::vector<util::Coordinate> &coordinates, std::vector<util::Coordinate> &coordinates,
extractor::PackedOSMIDs &osm_node_ids, extractor::PackedOSMIDs &osm_node_ids,
EdgeBasedNodeDataContainer &ebg_node_data_container, EdgeBasedNodeDataContainer &edge_based_nodes_container,
std::vector<EdgeBasedNode> &node_based_edges_list, std::vector<EdgeBasedNodeSegment> &edge_based_node_segments,
std::vector<bool> &node_is_startpoint, std::vector<bool> &node_is_startpoint,
std::vector<EdgeWeight> &edge_based_node_weights, std::vector<EdgeWeight> &edge_based_node_weights,
util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list, util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
@ -501,8 +499,8 @@ Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
*compressed_edge_container.ToSegmentData()); *compressed_edge_container.ToSegmentData());
edge_based_graph_factory.GetEdgeBasedEdges(edge_based_edge_list); edge_based_graph_factory.GetEdgeBasedEdges(edge_based_edge_list);
edge_based_graph_factory.GetEdgeBasedNodes(ebg_node_data_container); edge_based_graph_factory.GetEdgeBasedNodes(edge_based_nodes_container);
edge_based_graph_factory.GetNodeBasedEdges(node_based_edges_list); edge_based_graph_factory.GetEdgeBasedNodeSegments(edge_based_node_segments);
edge_based_graph_factory.GetStartPointMarkers(node_is_startpoint); edge_based_graph_factory.GetStartPointMarkers(node_is_startpoint);
edge_based_graph_factory.GetEdgeBasedNodeWeights(edge_based_node_weights); edge_based_graph_factory.GetEdgeBasedNodeWeights(edge_based_node_weights);
auto max_edge_id = edge_based_graph_factory.GetHighestEdgeID(); auto max_edge_id = edge_based_graph_factory.GetHighestEdgeID();
@ -522,21 +520,21 @@ Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
Saves tree into '.ramIndex' and leaves into '.fileIndex'. Saves tree into '.ramIndex' and leaves into '.fileIndex'.
*/ */
void Extractor::BuildRTree(std::vector<EdgeBasedNode> node_based_edges_list, void Extractor::BuildRTree(std::vector<EdgeBasedNodeSegment> edge_based_node_segments,
std::vector<bool> node_is_startpoint, std::vector<bool> node_is_startpoint,
const std::vector<util::Coordinate> &coordinates) const std::vector<util::Coordinate> &coordinates)
{ {
util::Log() << "constructing r-tree of " << node_based_edges_list.size() util::Log() << "Constructing r-tree of " << edge_based_node_segments.size()
<< " edge elements build on-top of " << coordinates.size() << " coordinates"; << " segments build on-top of " << coordinates.size() << " coordinates";
BOOST_ASSERT(node_is_startpoint.size() == node_based_edges_list.size()); BOOST_ASSERT(node_is_startpoint.size() == edge_based_node_segments.size());
// Filter node based edges based on startpoint // Filter node based edges based on startpoint
auto out_iter = node_based_edges_list.begin(); auto out_iter = edge_based_node_segments.begin();
auto in_iter = node_based_edges_list.begin(); auto in_iter = edge_based_node_segments.begin();
for (auto index : util::irange<std::size_t>(0UL, node_is_startpoint.size())) for (auto index : util::irange<std::size_t>(0UL, node_is_startpoint.size()))
{ {
BOOST_ASSERT(in_iter != node_based_edges_list.end()); BOOST_ASSERT(in_iter != edge_based_node_segments.end());
if (node_is_startpoint[index]) if (node_is_startpoint[index])
{ {
*out_iter = *in_iter; *out_iter = *in_iter;
@ -544,17 +542,17 @@ void Extractor::BuildRTree(std::vector<EdgeBasedNode> node_based_edges_list,
} }
in_iter++; in_iter++;
} }
auto new_size = out_iter - node_based_edges_list.begin(); auto new_size = out_iter - edge_based_node_segments.begin();
if (new_size == 0) if (new_size == 0)
{ {
throw util::exception("There are no snappable edges left after processing. Are you " throw util::exception("There are no snappable edges left after processing. Are you "
"setting travel modes correctly in the profile? Cannot continue." + "setting travel modes correctly in the profile? Cannot continue." +
SOURCE_REF); SOURCE_REF);
} }
node_based_edges_list.resize(new_size); edge_based_node_segments.resize(new_size);
TIMER_START(construction); TIMER_START(construction);
util::StaticRTree<EdgeBasedNode> rtree(node_based_edges_list, util::StaticRTree<EdgeBasedNodeSegment> rtree(edge_based_node_segments,
config.rtree_nodes_output_path, config.rtree_nodes_output_path,
config.rtree_leafs_output_path, config.rtree_leafs_output_path,
coordinates); coordinates);

4
unit_tests/util/static_rtree.cpp
View File

@ -1,5 +1,5 @@
#include "util/static_rtree.hpp" #include "util/static_rtree.hpp"
#include "extractor/edge_based_node.hpp" #include "extractor/edge_based_node_segment.hpp"
#include "engine/geospatial_query.hpp" #include "engine/geospatial_query.hpp"
#include "util/coordinate.hpp" #include "util/coordinate.hpp"
#include "util/coordinate_calculation.hpp" #include "util/coordinate_calculation.hpp"
@ -39,7 +39,7 @@ using namespace osrm::test;
constexpr uint32_t TEST_BRANCHING_FACTOR = 8; constexpr uint32_t TEST_BRANCHING_FACTOR = 8;
constexpr uint32_t TEST_LEAF_NODE_SIZE = 64; constexpr uint32_t TEST_LEAF_NODE_SIZE = 64;
using TestData = extractor::EdgeBasedNode; using TestData = extractor::EdgeBasedNodeSegment;
using TestStaticRTree = StaticRTree<TestData, using TestStaticRTree = StaticRTree<TestData,
osrm::storage::Ownership::Container, osrm::storage::Ownership::Container,
TEST_BRANCHING_FACTOR, TEST_BRANCHING_FACTOR,