From cb5931aaeb1e86c9093010f4cb64af3ab237db52 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Nov 2013 18:49:02 +0100 Subject: [PATCH] add skeleton for geometry compression --- Contractor/EdgeBasedGraphFactory.cpp | 108 ++++++++++++++++++++------- Contractor/EdgeBasedGraphFactory.h | 17 ++++- 2 files changed, 98 insertions(+), 27 deletions(-) diff --git a/Contractor/EdgeBasedGraphFactory.cpp b/Contractor/EdgeBasedGraphFactory.cpp index 5ce7434b6..c5f4cf3b5 100644 --- a/Contractor/EdgeBasedGraphFactory.cpp +++ b/Contractor/EdgeBasedGraphFactory.cpp @@ -27,6 +27,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "EdgeBasedGraphFactory.h" +//TODO: CompressionWorker +//TODO: EdgeBasedEdgeGenerator + +// template +// inline static void TraverseGraph(NodeBasedDynamicGraph & graph, Work & work) { + +// } + EdgeBasedGraphFactory::EdgeBasedGraphFactory( int number_of_nodes, std::vector & input_edge_list, @@ -35,10 +43,8 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory( std::vector & input_restrictions_list, std::vector & m_node_info_list, SpeedProfileProperties speed_profile -) : speed_profile(speed_profile), - m_turn_restrictions_count(0), - m_node_info_list(m_node_info_list) -{ +) : speed_profile(speed_profile), m_node_info_list(m_node_info_list) { + BOOST_FOREACH(const TurnRestriction & restriction, input_restrictions_list) { std::pair restriction_source = std::make_pair(restriction.fromNode, restriction.viaNode); @@ -56,11 +62,11 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory( continue; } else if(restriction.flags.isOnly) { //We are going to insert an is_only_*-restriction. There can be only one. - m_turn_restrictions_count -= m_restriction_bucket_list.at(index).size(); + stats.turn_restrictions_count -= m_restriction_bucket_list.at(index).size(); m_restriction_bucket_list.at(index).clear(); } } - ++m_turn_restrictions_count; + ++stats.turn_restrictions_count; m_restriction_bucket_list.at(index).push_back( std::make_pair( restriction.toNode, restriction.flags.isOnly) ); @@ -219,21 +225,73 @@ void EdgeBasedGraphFactory::Run( lua_State *lua_state ) { SimpleLogger().Write() << "Compressing geometry of input graph"; - //TODO: iterate over all turns + Percent p(m_node_based_graph->GetNumberOfNodes()); + // iterate over all turns + for( + NodeIterator u = 0, end = m_node_based_graph->GetNumberOfNodes(); + u < end; + ++u + ) { + for( + EdgeIterator e1 = m_node_based_graph->BeginEdges(u), + last_edge_u = m_node_based_graph->EndEdges(u); + e1 < last_edge_u; + ++e1 + ) { + ++stats.node_based_edge_counter; + const NodeIterator v = m_node_based_graph->GetTarget(e1); + const NodeID to_node_of_only_restriction = CheckForEmanatingIsOnlyTurn(u, v); + const bool is_barrier_node = ( m_barrier_nodes.find(v) != m_barrier_nodes.end() ); - //TODO: compress geometries + for( + EdgeIterator e2 = m_node_based_graph->BeginEdges(v), + last_edge_v = m_node_based_graph->EndEdges(v); + e2 < last_edge_v; + ++e2 + ) { + const NodeIterator w = m_node_based_graph->GetTarget(e2); + if( + to_node_of_only_restriction != UINT_MAX && + w != to_node_of_only_restriction + ) { + //We are at an only_-restriction but not at the right turn. + ++stats.skipped_turns_counter; + continue; + } - //TODO: update turn restrictions if concerned by compression + if( is_barrier_node && (u != w) ) { + ++stats.skipped_turns_counter; + continue; + } - //TODO: do some compression statistics + if( (u == w) && (1 != m_node_based_graph->GetOutDegree(v)) ) { + continue; + } + + //only add an edge if turn is not a U-turn except when it is + //at the end of a dead-end street + if ( + CheckIfTurnIsRestricted(u, v, w) && + (to_node_of_only_restriction == UINT_MAX) && + (w != to_node_of_only_restriction) + ) { + ++stats.skipped_turns_counter; + continue; + } + + //TODO: compress geometries, edgedata is congruent + + //TODO: update turn restrictions if concerned by compression + + } + } + } + + //TODO: print compression statistics SimpleLogger().Write() << "Identifying components of the road network"; - unsigned skipped_turns_counter = 0; - unsigned node_based_edge_counter = 0; - unsigned original_edges_counter = 0; - std::ofstream edge_data_file( original_edge_data_filename, std::ios::binary @@ -241,7 +299,7 @@ void EdgeBasedGraphFactory::Run( //writes a dummy value that is updated later edge_data_file.write( - (char*)&original_edges_counter, + (char*)&stats.original_edges_counter, sizeof(unsigned) ); @@ -255,7 +313,7 @@ void EdgeBasedGraphFactory::Run( SimpleLogger().Write() << "generating edge-expanded nodes"; - Percent p(m_node_based_graph->GetNumberOfNodes()); + p.reinit(m_node_based_graph->GetNumberOfNodes()); //loop over all edges and generate new set of nodes. for( NodeIterator u = 0, end = m_node_based_graph->GetNumberOfNodes(); @@ -320,7 +378,7 @@ void EdgeBasedGraphFactory::Run( e1 < last_edge_u; ++e1 ) { - ++node_based_edge_counter; + ++stats.node_based_edge_counter; const NodeIterator v = m_node_based_graph->GetTarget(e1); const NodeID to_node_of_only_restriction = CheckForEmanatingIsOnlyTurn(u, v); const bool is_barrier_node = ( m_barrier_nodes.find(v) != m_barrier_nodes.end() ); @@ -337,12 +395,12 @@ void EdgeBasedGraphFactory::Run( w != to_node_of_only_restriction ) { //We are at an only_-restriction but not at the right turn. - ++skipped_turns_counter; + ++stats.skipped_turns_counter; continue; } if( is_barrier_node && (u != w) ) { - ++skipped_turns_counter; + ++stats.skipped_turns_counter; continue; } @@ -357,7 +415,7 @@ void EdgeBasedGraphFactory::Run( (to_node_of_only_restriction == UINT_MAX) && (w != to_node_of_only_restriction) ) { - ++skipped_turns_counter; + ++stats.skipped_turns_counter; continue; } @@ -396,7 +454,7 @@ void EdgeBasedGraphFactory::Run( turnInstruction ) ); - ++original_edges_counter; + ++stats.original_edges_counter; if(original_edge_data_vector.size() > 100000) { FlushVectorToStream( @@ -422,20 +480,20 @@ void EdgeBasedGraphFactory::Run( FlushVectorToStream( edge_data_file, original_edge_data_vector ); edge_data_file.seekp( std::ios::beg ); - edge_data_file.write( (char*)&original_edges_counter, sizeof(unsigned) ); + edge_data_file.write( (char*)&stats.original_edges_counter, sizeof(unsigned) ); edge_data_file.close(); SimpleLogger().Write() << "Generated " << m_edge_based_node_list.size() << " edge based nodes"; SimpleLogger().Write() << - "Node-based graph contains " << node_based_edge_counter << " edges"; + "Node-based graph contains " << stats.node_based_edge_counter << " edges"; SimpleLogger().Write() << "Edge-expanded graph ..."; SimpleLogger().Write() << " contains " << m_edge_based_edge_list.size() << " edges"; SimpleLogger().Write() << - " skips " << skipped_turns_counter << " turns, " - "defined by " << m_turn_restrictions_count << " restrictions"; + " skips " << stats.skipped_turns_counter << " turns, " + "defined by " << stats.turn_restrictions_count << " restrictions"; } int EdgeBasedGraphFactory::GetTurnPenalty( diff --git a/Contractor/EdgeBasedGraphFactory.h b/Contractor/EdgeBasedGraphFactory.h index 053a6bfe9..97e18f650 100644 --- a/Contractor/EdgeBasedGraphFactory.h +++ b/Contractor/EdgeBasedGraphFactory.h @@ -101,6 +101,20 @@ public: unsigned GetNumberOfNodes() const; private: + struct EdgeBasedFactorStatistics { + EdgeBasedFactorStatistics() : + turn_restrictions_count(0), + skipped_turns_counter(0), + node_based_edge_counter(0), + original_edges_counter(0) + { } + + unsigned turn_restrictions_count; + unsigned skipped_turns_counter; + unsigned node_based_edge_counter; + unsigned original_edges_counter; + } stats; + struct NodeBasedEdgeData { int distance; unsigned edgeBasedNodeID; @@ -115,8 +129,6 @@ private: bool contraFlow:1; }; - unsigned m_turn_restrictions_count; - typedef DynamicGraph NodeBasedDynamicGraph; typedef NodeBasedDynamicGraph::InputEdge NodeBasedEdge; typedef NodeBasedDynamicGraph::NodeIterator NodeIterator; @@ -137,6 +149,7 @@ private: boost::unordered_set m_traffic_lights; RestrictionMap m_restriction_map; + GeometryCompressor m_geometry_compressor; NodeID CheckForEmanatingIsOnlyTurn( const NodeID u,