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

compressed geometries get serialized in R-tree

Browse Source
This commit is contained in:
Dennis Luxen 2014-02-20 17:49:18 +01:00
parent f7d5b0db9c
commit f16cb3c52d
3 changed files with 181 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

203
Contractor/EdgeBasedGraphFactory.cpp
View File

@ -35,6 +35,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <fstream> #include <fstream>
#include <iomanip> #include <iomanip>
#include <numeric>
EdgeBasedGraphFactory::EdgeBasedGraphFactory( EdgeBasedGraphFactory::EdgeBasedGraphFactory(
int number_of_nodes, int number_of_nodes,
@ -301,12 +302,11 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
for(EdgeIterator id = m_node_based_graph->BeginEdges(v); id < m_node_based_graph->EndEdges(v); ++id) { for(EdgeIterator id = m_node_based_graph->BeginEdges(v); id < m_node_based_graph->EndEdges(v); ++id) {
SimpleLogger().Write(logDEBUG) << " id: " << id << ", edge (" << v << "," << m_node_based_graph->GetTarget(id) << ")"; SimpleLogger().Write(logDEBUG) << " id: " << id << ", edge (" << v << "," << m_node_based_graph->GetTarget(id) << ")";
} }
SimpleLogger().Write() << "e1: " << e1 << "u: " << u << ", v: " << v;
SimpleLogger().Write() << std::setprecision(6) << m_node_info_list[u].lat/COORDINATE_PRECISION << "," << m_node_info_list[u].lon/COORDINATE_PRECISION << " <-> " << SimpleLogger().Write() << std::setprecision(6) << m_node_info_list[u].lat/COORDINATE_PRECISION << "," << m_node_info_list[u].lon/COORDINATE_PRECISION << " <-> " <<
m_node_info_list[v].lat/COORDINATE_PRECISION << "," << m_node_info_list[v].lon/COORDINATE_PRECISION; m_node_info_list[v].lat/COORDINATE_PRECISION << "," << m_node_info_list[v].lon/COORDINATE_PRECISION;
} }
BOOST_ASSERT( forward_data.edgeBasedNodeID != std::numeric_limits<unsigned>::max() ); BOOST_ASSERT( forward_data.edgeBasedNodeID != std::numeric_limits<unsigned>::max() );
SimpleLogger().Write() << "e1: " << e1 << "u: " << u << ", v: " << v;
if( forward_data.ignore_in_grid ) { if( forward_data.ignore_in_grid ) {
// SimpleLogger().Write(logDEBUG) << "skipped edge at " << m_node_info_list[u].lat << "," << // SimpleLogger().Write(logDEBUG) << "skipped edge at " << m_node_info_list[u].lat << "," <<
@ -320,9 +320,11 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
// find reverse edge id and // find reverse edge id and
const EdgeID e2 = m_node_based_graph->FindEdge(v, u); const EdgeID e2 = m_node_based_graph->FindEdge(v, u);
#ifndef NDEBUG
if ( e2 == m_node_based_graph->EndEdges(v) ) { if ( e2 == m_node_based_graph->EndEdges(v) ) {
SimpleLogger().Write(logDEBUG) << "Did not find edge (" << v << "," << u << ")"; SimpleLogger().Write(logDEBUG) << "Did not find edge (" << v << "," << u << ")";
} }
#endif NDEBUG
BOOST_ASSERT( e2 != std::numeric_limits<unsigned>::max() ); BOOST_ASSERT( e2 != std::numeric_limits<unsigned>::max() );
BOOST_ASSERT( e2 < m_node_based_graph->EndEdges(v) ); BOOST_ASSERT( e2 < m_node_based_graph->EndEdges(v) );
const EdgeData & reverse_data = m_node_based_graph->GetEdgeData(e2); const EdgeData & reverse_data = m_node_based_graph->GetEdgeData(e2);
@ -350,76 +352,136 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
const std::vector<GeometryCompressor::CompressedNode> & reverse_geometry = m_geometry_compressor.GetBucketReference(e2); const std::vector<GeometryCompressor::CompressedNode> & reverse_geometry = m_geometry_compressor.GetBucketReference(e2);
BOOST_ASSERT( forward_geometry.size() == reverse_geometry.size() ); BOOST_ASSERT( forward_geometry.size() == reverse_geometry.size() );
BOOST_ASSERT( 0 != forward_geometry.size() ); BOOST_ASSERT( 0 != forward_geometry.size() );
// for( unsigned i = 0; i < reverse_geometry.size(); ++i ) {
// if( forward_geometry[i].first != reverse_geometry.back().first ) {
// #ifndef NDEBUG
// //Dumps debug information when data is borked
// SimpleLogger().Write() << "size1: " << forward_geometry.size() << ", size2: " << reverse_geometry.size();
// SimpleLogger().Write() << "index1: " << i << ", index2: " << reverse_geometry.size()-1-i;
// SimpleLogger().Write() << forward_geometry[0].first << "!=" << reverse_geometry[reverse_geometry.size()-1-i].first;
// BOOST_FOREACH(const GeometryCompressor::CompressedNode geometry_node, forward_geometry) {
// SimpleLogger().Write(logDEBUG) << "fwd node " << geometry_node.first << "," << m_node_info_list[geometry_node.first].lat/COORDINATE_PRECISION << "," << m_node_info_list[geometry_node.first].lon/COORDINATE_PRECISION;
// }
// BOOST_FOREACH(const GeometryCompressor::CompressedNode geometry_node, reverse_geometry) {
// SimpleLogger().Write(logDEBUG) << "rev node " << geometry_node.first << "," << m_node_info_list[geometry_node.first].lat/COORDINATE_PRECISION << "," << m_node_info_list[geometry_node.first].lon/COORDINATE_PRECISION;
// }
// #endif
// }
// BOOST_ASSERT( forward_geometry[i].first == reverse_geometry[reverse_geometry.size()-1-i].first );
// }
//TODO reconstruct bidirectional edge with weights.
int fwd_sum_of_weights = 0; int fwd_sum_of_weights = 0;
NodeID fwd_start_node = u; NodeID fwd_start_node = u;
// SimpleLogger().Write(logDEBUG) << "fwd node " << "weight" << "," << m_node_info_list[u].lat/COORDINATE_PRECISION << "," << m_node_info_list[u].lon/COORDINATE_PRECISION; // SimpleLogger().Write(logDEBUG) << "fwd node " << "weight" << "," << m_node_info_list[u].lat/COORDINATE_PRECISION << "," << m_node_info_list[u].lon/COORDINATE_PRECISION;
SimpleLogger().Write(logDEBUG) << "fwd edge id: " << e1; // if( 1 == e1 ) {
BOOST_FOREACH(const GeometryCompressor::CompressedNode geometry_node, forward_geometry) { // SimpleLogger().Write(logDEBUG) << "fwd edge id: " << e1;
NodeID fwd_end_node = geometry_node.first; // }
EdgeWeight fwd_weight = geometry_node.second; BOOST_FOREACH(const GeometryCompressor::CompressedNode & geometry_node, forward_geometry) {
const NodeID fwd_end_node = geometry_node.first;
const EdgeWeight fwd_weight = geometry_node.second;
// SimpleLogger().Write(logDEBUG) << "fwd node " << geometry_node.first << "," << m_node_info_list[geometry_node.first].lat/COORDINATE_PRECISION << "," << m_node_info_list[geometry_node.first].lon/COORDINATE_PRECISION << ", w: " << geometry_node.second; // SimpleLogger().Write(logDEBUG) << "fwd node " << geometry_node.first << "," << m_node_info_list[geometry_node.first].lat/COORDINATE_PRECISION << "," << m_node_info_list[geometry_node.first].lon/COORDINATE_PRECISION << ", w: " << geometry_node.second;
fwd_sum_of_weights += geometry_node.second; fwd_sum_of_weights += fwd_weight;
SimpleLogger().Write(logDEBUG) << "fwd-edge (" << fwd_start_node << "," << fwd_end_node << "), w: " << fwd_weight; // if( 1 == e1 ) {
// SimpleLogger().Write(logDEBUG) << "fwd-edge (" << fwd_start_node << "," << fwd_end_node << "), w: " << fwd_weight;
// }
fwd_start_node = fwd_end_node; fwd_start_node = fwd_end_node;
} }
SimpleLogger().Write(logDEBUG) << "fwd-edge (" << fwd_start_node << "," << v << "), w: " << (forward_data.distance - fwd_sum_of_weights); // if( 1 == e1 ) {
// SimpleLogger().Write(logDEBUG) << "fwd-edge (" << fwd_start_node << "," << v << "), w: " << (forward_data.distance - fwd_sum_of_weights);
// }
// SimpleLogger().Write(logDEBUG) << "fwd node " << "weight" << "," << m_node_info_list[v].lat/COORDINATE_PRECISION << "," << m_node_info_list[v].lon/COORDINATE_PRECISION;
// SimpleLogger().Write(logDEBUG) << "rev node " << "weight" << "," << m_node_info_list[v].lat/COORDINATE_PRECISION << "," << m_node_info_list[v].lon/COORDINATE_PRECISION;
// BOOST_FOREACH(const GeometryCompressor::CompressedNode geometry_node, reverse_geometry) {
// SimpleLogger().Write(logDEBUG) << "rev node " << geometry_node.first << "," << m_node_info_list[geometry_node.first].lat/COORDINATE_PRECISION << "," << m_node_info_list[geometry_node.first].lon/COORDINATE_PRECISION;
// }
// SimpleLogger().Write(logDEBUG) << "rev node " << "weight" << "," << m_node_info_list[u].lat/COORDINATE_PRECISION << "," << m_node_info_list[u].lon/COORDINATE_PRECISION;
// SimpleLogger().Write(logDEBUG) << "fwd node " << "weight" << "," << m_node_info_list[v].lat/COORDINATE_PRECISION << "," << m_node_info_list[v].lon/COORDINATE_PRECISION; // if( 1 == e1 ) {
// SimpleLogger().Write(logDEBUG) << "rev node " << "weight" << "," << m_node_info_list[v].lat/COORDINATE_PRECISION << "," << m_node_info_list[v].lon/COORDINATE_PRECISION; // SimpleLogger().Write(logDEBUG) << "fwd sum of edge weights: " << fwd_sum_of_weights;
// BOOST_FOREACH(const GeometryCompressor::CompressedNode geometry_node, reverse_geometry) { // SimpleLogger().Write(logDEBUG) << "c'ted edge weight: " << forward_data.distance;
// SimpleLogger().Write(logDEBUG) << "rev node " << geometry_node.first << "," << m_node_info_list[geometry_node.first].lat/COORDINATE_PRECISION << "," << m_node_info_list[geometry_node.first].lon/COORDINATE_PRECISION; // SimpleLogger().Write(logDEBUG) << "weight diff: " << (forward_data.distance - fwd_sum_of_weights);
// } // }
// SimpleLogger().Write(logDEBUG) << "rev node " << "weight" << "," << m_node_info_list[u].lat/COORDINATE_PRECISION << "," << m_node_info_list[u].lon/COORDINATE_PRECISION; BOOST_ASSERT( forward_data.distance == fwd_sum_of_weights );
SimpleLogger().Write(logDEBUG) << "fwd sum of edge weights: " << fwd_sum_of_weights;
SimpleLogger().Write(logDEBUG) << "c'ted edge weight: " << forward_data.distance;
SimpleLogger().Write(logDEBUG) << "weight diff: " << (forward_data.distance - fwd_sum_of_weights);
int rev_sum_of_weights = 0; int rev_sum_of_weights = 0;
NodeID rev_start_node = v; NodeID rev_start_node = v;
// SimpleLogger().Write(logDEBUG) << "fwd node " << "weight" << "," << m_node_info_list[u].lat/COORDINATE_PRECISION << "," << m_node_info_list[u].lon/COORDINATE_PRECISION; // SimpleLogger().Write(logDEBUG) << "fwd node " << "weight" << "," << m_node_info_list[u].lat/COORDINATE_PRECISION << "," << m_node_info_list[u].lon/COORDINATE_PRECISION;
BOOST_FOREACH(const GeometryCompressor::CompressedNode geometry_node, reverse_geometry) { BOOST_FOREACH(const GeometryCompressor::CompressedNode & geometry_node, reverse_geometry) {
NodeID rev_end_node = geometry_node.first; const NodeID rev_end_node = geometry_node.first;
EdgeWeight rev_weight = geometry_node.second; const EdgeWeight rev_weight = geometry_node.second;
// SimpleLogger().Write(logDEBUG) << "fwd node " << geometry_node.first << "," << m_node_info_list[geometry_node.first].lat/COORDINATE_PRECISION << "," << m_node_info_list[geometry_node.first].lon/COORDINATE_PRECISION << ", w: " << geometry_node.second; // SimpleLogger().Write(logDEBUG) << "rev node " << geometry_node.first << "," << m_node_info_list[geometry_node.first].lat/COORDINATE_PRECISION << "," << m_node_info_list[geometry_node.first].lon/COORDINATE_PRECISION << ", w: " << geometry_node.second;
rev_sum_of_weights += geometry_node.second; rev_sum_of_weights += rev_weight;
SimpleLogger().Write(logDEBUG) << "Edge (" << rev_start_node << "," << rev_end_node << "), w: " << rev_weight; // if( 1 == e1 ) {
// SimpleLogger().Write(logDEBUG) << "Edge (" << rev_start_node << "," << rev_end_node << "), w: " << rev_weight;
// }
rev_start_node = rev_end_node; rev_start_node = rev_end_node;
} }
SimpleLogger().Write(logDEBUG) << "Edge (" << rev_start_node << "," << u << "), w: " << (reverse_data.distance - rev_sum_of_weights); // if( 1 == e1 ) {
// SimpleLogger().Write(logDEBUG) << "Edge (" << rev_start_node << "," << u << "), w: " << (reverse_data.distance - rev_sum_of_weights);
SimpleLogger().Write(logDEBUG) << "rev sum of edge weights: " << rev_sum_of_weights; // SimpleLogger().Write(logDEBUG) << "rev sum of edge weights: " << rev_sum_of_weights;
SimpleLogger().Write(logDEBUG) << "c'ted edge weight: " << reverse_data.distance; // SimpleLogger().Write(logDEBUG) << "c'ted edge weight: " << reverse_data.distance;
SimpleLogger().Write(logDEBUG) << "weight diff: " << (reverse_data.distance - rev_sum_of_weights); // SimpleLogger().Write(logDEBUG) << "weight diff: " << (reverse_data.distance - rev_sum_of_weights);
BOOST_ASSERT(false);
BOOST_ASSERT( reverse_data.distance == rev_sum_of_weights );
// // BOOST_ASSERT(false);
// }
// SimpleLogger().Write(logDEBUG) << "start " << m_node_info_list[u].lat << "," << m_node_info_list[u].lon; // SimpleLogger().Write(logDEBUG) << "start " << m_node_info_list[u].lat << "," << m_node_info_list[u].lon;
// SimpleLogger().Write(logDEBUG) << "target " << m_node_info_list[v].lat << "," << m_node_info_list[v].lon; // SimpleLogger().Write(logDEBUG) << "target " << m_node_info_list[v].lat << "," << m_node_info_list[v].lon;
// BOOST_ASSERT( false ); // BOOST_ASSERT( false );
//TODO reconstruct bidirectional edge with individual weights and put each into the NN index
std::vector<int> forward_dist_prefix_sum( forward_geometry.size() );
std::vector<int> reverse_dist_prefix_sum( reverse_geometry.size() );
//quick'n'dirty prefix sum as std::partial_sum needs addtional casts
// SimpleLogger().Write(logDEBUG) << "Prefix sums of edge " << e1 << ", w: " << reverse_data.distance;
int temp_sum = 0;
for( unsigned i = 0; i < forward_geometry.size(); ++i ) {
temp_sum += forward_geometry[i].second;
BOOST_ASSERT( forward_data.distance >= temp_sum );
forward_dist_prefix_sum[i] = forward_data.distance - temp_sum;
// SimpleLogger().Write(logDEBUG) << "[" << i << "]" << temp_sum << ", n: " << forward_geometry[i].first << ", loc: " << m_node_info_list[forward_geometry[i].first].lat/COORDINATE_PRECISION << "," << m_node_info_list[forward_geometry[i].first].lon/COORDINATE_PRECISION;
}
BOOST_ASSERT( forward_data.distance == temp_sum );
temp_sum = 0;
for( unsigned i = 0; i < reverse_geometry.size(); ++i ) {
temp_sum += reverse_geometry[i].second;
BOOST_ASSERT( reverse_data.distance >= temp_sum );
reverse_dist_prefix_sum[i] = reverse_data.distance - temp_sum;
// SimpleLogger().Write(logDEBUG) << "[" << i << "]" << temp_sum << ", n: " << reverse_geometry[i].first << ", loc: " << m_node_info_list[reverse_geometry[i].first].lat/COORDINATE_PRECISION << "," << m_node_info_list[reverse_geometry[i].first].lon/COORDINATE_PRECISION;
}
BOOST_ASSERT( reverse_data.distance == temp_sum );
BOOST_ASSERT( forward_geometry.size() == reverse_geometry.size() );
const unsigned geometry_size = forward_geometry.size();
NodeID first_node_of_edge = u;
// traverse arrays from start and end respectively
for( unsigned i = 0; i < geometry_size; ++i ) {
BOOST_ASSERT( first_node_of_edge == reverse_geometry[geometry_size-1-i].first );
const NodeID last_coordinate_id = forward_geometry[i].first;
// SimpleLogger().Write() << "adding edge (" << first_node_of_edge << "," << forward_geometry[i].first << ") ";
// SimpleLogger().Write() << "fwd w: " << forward_geometry[i].second << ", fwd o: " << forward_dist_prefix_sum[i];
// SimpleLogger().Write() << "rev w: " << reverse_geometry[geometry_size-1-i].second << ", rev o: " << reverse_dist_prefix_sum[geometry_size-1-i];
//TODO: build edges
m_edge_based_node_list.push_back(
EdgeBasedNode(
forward_data.edgeBasedNodeID,
reverse_data.edgeBasedNodeID,
m_node_info_list[first_node_of_edge].lat,
m_node_info_list[first_node_of_edge].lon,
m_node_info_list[forward_geometry[i].first].lat,
m_node_info_list[forward_geometry[i].first].lon,
belongs_to_tiny_cc,//TODO
forward_data.nameID,
forward_geometry[i].second,
reverse_geometry[geometry_size-1-i].second,
forward_dist_prefix_sum[i],
reverse_dist_prefix_sum[geometry_size-1-i]
)
);
first_node_of_edge = last_coordinate_id;
}
//TODO: Manually reconstruct last edge.
if( first_node_of_edge != v ) {
SimpleLogger().Write(logDEBUG) << "first_node_of_edge:" << first_node_of_edge << ", u: " << u << ", v: " << v;
}
// BOOST_ASSERT( false );
BOOST_ASSERT( first_node_of_edge == v );
} else { } else {
BOOST_ASSERT( !m_geometry_compressor.HasEntryForID(e2) ); BOOST_ASSERT( !m_geometry_compressor.HasEntryForID(e2) );
@ -537,32 +599,17 @@ void EdgeBasedGraphFactory::Run(
rev_edge_data1.IsEqualTo(rev_edge_data2) rev_edge_data1.IsEqualTo(rev_edge_data2)
) { ) {
//Get distances before graph is modified //Get distances before graph is modified
const bool fwd_e1_is_compressed = m_geometry_compressor.HasEntryForID(forward_e1); const int forward_weight1 = m_node_based_graph->GetEdgeData(forward_e1).distance;
int forward_weight1 = 0; const int forward_weight2 = m_node_based_graph->GetEdgeData(forward_e2).distance;
if( fwd_e1_is_compressed ) {
forward_weight1 = m_geometry_compressor.GetBucketReference(forward_e1).back().second;
} else {
forward_weight1 = m_node_based_graph->GetEdgeData(forward_e1).distance;
}
if( 0 == forward_e1 ) {
SimpleLogger().Write(logDEBUG) << (fwd_e1_is_compressed ? "fetched" : "used") << " fwd weight: " << forward_weight1;
}
BOOST_ASSERT( 0 != forward_weight1 ); BOOST_ASSERT( 0 != forward_weight1 );
// const int forward_weight2 = fwd_edge_data2.distance; BOOST_ASSERT( 0 != forward_weight2 );
const int reverse_weight1 = m_node_based_graph->GetEdgeData(reverse_e1).distance;
const int reverse_weight2 = m_node_based_graph->GetEdgeData(reverse_e2).distance;
const bool rev_e1_is_compressed = m_geometry_compressor.HasEntryForID(reverse_e1);
int reverse_weight1 = 0;
if( rev_e1_is_compressed ) {
reverse_weight1 = m_geometry_compressor.GetBucketReference(reverse_e1).back().second;
} else {
reverse_weight1 = m_node_based_graph->GetEdgeData(reverse_e1).distance;
}
BOOST_ASSERT( 0 != reverse_weight1 ); BOOST_ASSERT( 0 != reverse_weight1 );
if( 0 == reverse_e1 ) { BOOST_ASSERT( 0 != forward_weight2 );
SimpleLogger().Write(logDEBUG) << (rev_e1_is_compressed ? "fetched" : "used") << " fwd weight: " << reverse_weight1;
}
// add weight of e2's to e1 // add weight of e2's to e1
m_node_based_graph->GetEdgeData(forward_e1).distance += fwd_edge_data2.distance; m_node_based_graph->GetEdgeData(forward_e1).distance += fwd_edge_data2.distance;
@ -590,15 +637,17 @@ void EdgeBasedGraphFactory::Run(
forward_e1, forward_e1,
forward_e2, forward_e2,
v, v,
forward_weight1//, w,
// forward_weight2 forward_weight1,
forward_weight2
); );
m_geometry_compressor.CompressEdge( m_geometry_compressor.CompressEdge(
reverse_e1, reverse_e1,
reverse_e2, reverse_e2,
v, v,
reverse_weight1//, u,
// reverse_weight2 reverse_weight1,
reverse_weight2
); );
++removed_node_count; ++removed_node_count;
@ -858,7 +907,7 @@ void EdgeBasedGraphFactory::Run(
const bool edge_is_compressed = m_geometry_compressor.HasEntryForID(e1); const bool edge_is_compressed = m_geometry_compressor.HasEntryForID(e1);
if(edge_is_compressed) { if(edge_is_compressed) {
++compressed; ++compressed;
m_geometry_compressor.AddLastViaNodeIDToCompressedEdge(e1, v, /*TODO*/ 1); // m_geometry_compressor.AddLastViaNodeIDToCompressedEdge(e1, v, /*TODO*/ 1);
if ( 0 == m_geometry_compressor.GetPositionForID(e1) ) { if ( 0 == m_geometry_compressor.GetPositionForID(e1) ) {
SimpleLogger().Write(logDEBUG) << "e1: " << e1 << " is zero with via node: " << v; SimpleLogger().Write(logDEBUG) << "e1: " << e1 << " is zero with via node: " << v;
} }

106
Contractor/GeometryCompressor.cpp
View File

@ -61,23 +61,6 @@ unsigned GeometryCompressor::GetPositionForID(const EdgeID edge_id) const {
return map_iterator->second; return map_iterator->second;
} }
void GeometryCompressor::AddLastViaNodeIDToCompressedEdge(
const EdgeID edge_id,
const NodeID node_id,
const EdgeWeight weight
) {
unsigned index = GetPositionForID(edge_id);
BOOST_ASSERT( index < m_compressed_geometries.size() );
if( !m_compressed_geometries[index].empty() ) {
if( m_compressed_geometries[index].back().first == node_id ) {
return;
}
}
BOOST_ASSERT( node_id != m_compressed_geometries[index].back().first );
m_compressed_geometries[index].push_back( std::make_pair(node_id, weight) );
BOOST_ASSERT( node_id == m_compressed_geometries[index].back().first );
}
void GeometryCompressor::SerializeInternalVector( void GeometryCompressor::SerializeInternalVector(
const std::string & path const std::string & path
) const { ) const {
@ -139,27 +122,31 @@ void GeometryCompressor::SerializeInternalVector(
} }
void GeometryCompressor::CompressEdge( void GeometryCompressor::CompressEdge(
const EdgeID surviving_edge_id, const EdgeID edge_id_1,
const EdgeID removed_edge_id, const EdgeID edge_id_2,
const NodeID via_node_id, const NodeID via_node_id,
const EdgeWeight weight1//, const NodeID target_node_id,
// const EdgeWeight weight2 const EdgeWeight weight1,
const EdgeWeight weight2
) { ) {
BOOST_ASSERT( SPECIAL_EDGEID != surviving_edge_id ); BOOST_ASSERT( SPECIAL_EDGEID != edge_id_1 );
BOOST_ASSERT( SPECIAL_NODEID != removed_edge_id ); BOOST_ASSERT( SPECIAL_EDGEID != edge_id_2 );
BOOST_ASSERT( SPECIAL_NODEID != via_node_id ); BOOST_ASSERT( SPECIAL_NODEID != via_node_id );
BOOST_ASSERT( SPECIAL_NODEID != target_node_id );
BOOST_ASSERT( std::numeric_limits<unsigned>::max() != weight1 ); BOOST_ASSERT( std::numeric_limits<unsigned>::max() != weight1 );
BOOST_ASSERT( std::numeric_limits<unsigned>::max() != weight2 );
// append list of removed edge_id plus via node to surviving edge id: // append list of removed edge_id plus via node to surviving edge id:
// <surv_1, .. , surv_n, via_node_id, rem_1, .. rem_n // <surv_1, .. , surv_n, via_node_id, rem_1, .. rem_n
// //
// General scheme: // General scheme:
// 1. append via node id to list of surviving_edge_id // 1. append via node id to list of edge_id_1
// 2. find list for removed_edge_id, if yes add all elements and delete it // 2. find list for edge_id_2, if yes add all elements and delete it
// Add via node id. List is created if it does not exist // Add via node id. List is created if it does not exist
if( if(
m_edge_id_to_list_index_map.find(surviving_edge_id) == m_edge_id_to_list_index_map.end() !HasEntryForID(edge_id_1)
) { ) {
// create a new entry in the map // create a new entry in the map
if( 0 == m_free_list.size() ) { if( 0 == m_free_list.size() ) {
@ -169,60 +156,57 @@ void GeometryCompressor::CompressEdge(
} }
BOOST_ASSERT( !m_free_list.empty() ); BOOST_ASSERT( !m_free_list.empty() );
// SimpleLogger().Write() << "free list size: " << m_free_list.size(); // SimpleLogger().Write() << "free list size: " << m_free_list.size();
m_edge_id_to_list_index_map[surviving_edge_id] = m_free_list.back(); m_edge_id_to_list_index_map[edge_id_1] = m_free_list.back();
m_free_list.pop_back(); m_free_list.pop_back();
} }
const unsigned surving_list_id = m_edge_id_to_list_index_map[surviving_edge_id];
BOOST_ASSERT( surving_list_id == GetPositionForID(surviving_edge_id));
// SimpleLogger().Write() << "surviving edge id " << surviving_edge_id << " is listed at " << surving_list_id; const unsigned edge_bucket_id1 = m_edge_id_to_list_index_map[edge_id_1];
BOOST_ASSERT( surving_list_id < m_compressed_geometries.size() ); BOOST_ASSERT( edge_bucket_id1 == GetPositionForID(edge_id_1));
BOOST_ASSERT( edge_bucket_id1 < m_compressed_geometries.size() );
std::vector<CompressedNode> & surviving_geometry_list = m_compressed_geometries[surving_list_id]; std::vector<CompressedNode> & edge_bucket_list1 = m_compressed_geometries[edge_bucket_id1];
BOOST_ASSERT(
surviving_geometry_list.empty() ||
( via_node_id != surviving_geometry_list.back().first )
);
if(surviving_edge_id == 0) { if( 0 == edge_id_1 ) {
SimpleLogger().Write(logDEBUG) << "adding via " << via_node_id << ", w: " << weight1; SimpleLogger().Write(logDEBUG) << "adding via " << via_node_id << ", w: " << weight1;
} }
surviving_geometry_list.push_back( std::make_pair(via_node_id, weight1) ); if( edge_bucket_list1.empty() ) {
BOOST_ASSERT( 0 < surviving_geometry_list.size() ); edge_bucket_list1.push_back( std::make_pair(via_node_id, weight1) );
BOOST_ASSERT( !surviving_geometry_list.empty() ); }
// Find any existing list for removed_edge_id BOOST_ASSERT( 0 < edge_bucket_list1.size() );
typename boost::unordered_map<EdgeID, unsigned>::const_iterator remove_list_iterator; BOOST_ASSERT( !edge_bucket_list1.empty() );
remove_list_iterator = m_edge_id_to_list_index_map.find(removed_edge_id);
if( m_edge_id_to_list_index_map.end() != remove_list_iterator ) { if( HasEntryForID(edge_id_2) ) {
const unsigned list_to_remove_index = remove_list_iterator->second; // second edge is not atomic anymore
BOOST_ASSERT( list_to_remove_index == GetPositionForID(removed_edge_id)); const unsigned list_to_remove_index = GetPositionForID(edge_id_2);
BOOST_ASSERT( list_to_remove_index < m_compressed_geometries.size() ); BOOST_ASSERT( list_to_remove_index < m_compressed_geometries.size() );
std::vector<CompressedNode> & remove_geometry_list = m_compressed_geometries[list_to_remove_index]; std::vector<CompressedNode> & edge_bucket_list2 = m_compressed_geometries[list_to_remove_index];
if(surviving_edge_id == 0) { if( 0 == edge_id_1 ) {
SimpleLogger().Write(logDEBUG) << "appending to list: "; SimpleLogger().Write(logDEBUG) << "appending to list: ";
BOOST_FOREACH(const CompressedNode & node, remove_geometry_list) { BOOST_FOREACH(const CompressedNode & node, edge_bucket_list2) {
SimpleLogger().Write(logDEBUG) << "adding via " << node.first << ", w: " << node.second; SimpleLogger().Write(logDEBUG) << "adding via " << node.first << ", w: " << node.second;
} }
} }
// found an existing list, append it to the list of edge_id_1
// found an existing list, append it to the list of surviving_edge_id edge_bucket_list1.insert(
surviving_geometry_list.insert( edge_bucket_list1.end(),
surviving_geometry_list.end(), edge_bucket_list2.begin(),
remove_geometry_list.begin(), edge_bucket_list2.end()
remove_geometry_list.end()
); );
//remove the list of removed_edge_id //remove the list of edge_id_2
m_edge_id_to_list_index_map.erase(remove_list_iterator); m_edge_id_to_list_index_map.erase(edge_id_2);
BOOST_ASSERT( m_edge_id_to_list_index_map.end() == m_edge_id_to_list_index_map.find(removed_edge_id) ); BOOST_ASSERT( m_edge_id_to_list_index_map.end() == m_edge_id_to_list_index_map.find(edge_id_2) );
remove_geometry_list.clear(); edge_bucket_list2.clear();
BOOST_ASSERT( 0 == remove_geometry_list.size() ); BOOST_ASSERT( 0 == edge_bucket_list2.size() );
m_free_list.push_back(list_to_remove_index); m_free_list.push_back(list_to_remove_index);
BOOST_ASSERT( list_to_remove_index == m_free_list.back() ); BOOST_ASSERT( list_to_remove_index == m_free_list.back() );
} else {
// we are certain that the second edge is atomic.
edge_bucket_list1.push_back( std::make_pair(target_node_id, weight2) );
} }
} }

19
Contractor/GeometryCompressor.h
View File

@ -42,18 +42,19 @@ public:
GeometryCompressor(); GeometryCompressor();
void CompressEdge( void CompressEdge(
const EdgeID first_edge_id, const EdgeID surviving_edge_id,
const EdgeID second_edge_id, const EdgeID removed_edge_id,
const NodeID via_node_id, const NodeID via_node_id,
const EdgeWeight weight1//, const NodeID target_node,
// const EdgeWeight weight2 const EdgeWeight weight1,
const EdgeWeight weight2
); );
void AddLastViaNodeIDToCompressedEdge( // void AddLastViaNodeIDToCompressedEdge(
const EdgeID edge_id, // const EdgeID edge_id,
const NodeID node_id, // const NodeID node_id,
const EdgeWeight weight // const EdgeWeight weight
); // );
bool HasEntryForID(const EdgeID edge_id) const; bool HasEntryForID(const EdgeID edge_id) const;
void PrintStatistics() const; void PrintStatistics() const;
void SerializeInternalVector(const std::string & path) const; void SerializeInternalVector(const std::string & path) const;