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

191
Contractor/EdgeBasedGraphFactory.cpp
View File

@ -35,6 +35,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <fstream>
#include <iomanip>
#include <numeric>
EdgeBasedGraphFactory::EdgeBasedGraphFactory(
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) {
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 << " <-> " <<
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() );
SimpleLogger().Write() << "e1: " << e1 << "u: " << u << ", v: " << v;
if( forward_data.ignore_in_grid ) {
// SimpleLogger().Write(logDEBUG) << "skipped edge at " << m_node_info_list[u].lat << "," <<
@ -320,9 +320,11 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
// find reverse edge id and
const EdgeID e2 = m_node_based_graph->FindEdge(v, u);
#ifndef NDEBUG
if ( e2 == m_node_based_graph->EndEdges(v) ) {
SimpleLogger().Write(logDEBUG) << "Did not find edge (" << v << "," << u << ")";
}
#endif NDEBUG
BOOST_ASSERT( e2 != std::numeric_limits<unsigned>::max() );
BOOST_ASSERT( e2 < m_node_based_graph->EndEdges(v) );
const EdgeData & reverse_data = m_node_based_graph->GetEdgeData(e2);
@ -350,40 +352,27 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
const std::vector<GeometryCompressor::CompressedNode> & reverse_geometry = m_geometry_compressor.GetBucketReference(e2);
BOOST_ASSERT( forward_geometry.size() == reverse_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;
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 edge id: " << e1;
BOOST_FOREACH(const GeometryCompressor::CompressedNode geometry_node, forward_geometry) {
NodeID fwd_end_node = geometry_node.first;
EdgeWeight fwd_weight = geometry_node.second;
// if( 1 == e1 ) {
// SimpleLogger().Write(logDEBUG) << "fwd edge id: " << e1;
// }
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;
fwd_sum_of_weights += geometry_node.second;
SimpleLogger().Write(logDEBUG) << "fwd-edge (" << fwd_start_node << "," << fwd_end_node << "), w: " << fwd_weight;
fwd_sum_of_weights += 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;
}
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) {
@ -391,35 +380,108 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
// }
// 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 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);
// if( 1 == e1 ) {
// 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);
// }
BOOST_ASSERT( forward_data.distance == fwd_sum_of_weights );
int rev_sum_of_weights = 0;
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;
BOOST_FOREACH(const GeometryCompressor::CompressedNode geometry_node, reverse_geometry) {
NodeID rev_end_node = geometry_node.first;
EdgeWeight rev_weight = geometry_node.second;
BOOST_FOREACH(const GeometryCompressor::CompressedNode & geometry_node, reverse_geometry) {
const NodeID rev_end_node = geometry_node.first;
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;
rev_sum_of_weights += geometry_node.second;
SimpleLogger().Write(logDEBUG) << "Edge (" << rev_start_node << "," << rev_end_node << "), w: " << rev_weight;
// 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 += rev_weight;
// if( 1 == e1 ) {
// SimpleLogger().Write(logDEBUG) << "Edge (" << rev_start_node << "," << rev_end_node << "), w: " << rev_weight;
// }
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) << "c'ted edge weight: " << reverse_data.distance;
SimpleLogger().Write(logDEBUG) << "weight diff: " << (reverse_data.distance - rev_sum_of_weights);
BOOST_ASSERT(false);
// 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) << "weight diff: " << (reverse_data.distance - rev_sum_of_weights);
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) << "target " << m_node_info_list[v].lat << "," << m_node_info_list[v].lon;
// 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 {
BOOST_ASSERT( !m_geometry_compressor.HasEntryForID(e2) );
@ -537,32 +599,17 @@ void EdgeBasedGraphFactory::Run(
rev_edge_data1.IsEqualTo(rev_edge_data2)
) {
//Get distances before graph is modified
const bool fwd_e1_is_compressed = m_geometry_compressor.HasEntryForID(forward_e1);
int forward_weight1 = 0;
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;
}
const int forward_weight1 = m_node_based_graph->GetEdgeData(forward_e1).distance;
const int forward_weight2 = m_node_based_graph->GetEdgeData(forward_e2).distance;
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 );
if( 0 == reverse_e1 ) {
SimpleLogger().Write(logDEBUG) << (rev_e1_is_compressed ? "fetched" : "used") << " fwd weight: " << reverse_weight1;
}
BOOST_ASSERT( 0 != forward_weight2 );
// add weight of e2's to e1
m_node_based_graph->GetEdgeData(forward_e1).distance += fwd_edge_data2.distance;
@ -590,15 +637,17 @@ void EdgeBasedGraphFactory::Run(
forward_e1,
forward_e2,
v,
forward_weight1//,
// forward_weight2
w,
forward_weight1,
forward_weight2
);
m_geometry_compressor.CompressEdge(
reverse_e1,
reverse_e2,
v,
reverse_weight1//,
// reverse_weight2
u,
reverse_weight1,
reverse_weight2
);
++removed_node_count;
@ -858,7 +907,7 @@ void EdgeBasedGraphFactory::Run(
const bool edge_is_compressed = m_geometry_compressor.HasEntryForID(e1);
if(edge_is_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) ) {
SimpleLogger().Write(logDEBUG) << "e1: " << e1 << " is zero with via node: " << v;
}

104
Contractor/GeometryCompressor.cpp
View File

@ -61,23 +61,6 @@ unsigned GeometryCompressor::GetPositionForID(const EdgeID edge_id) const {
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(
const std::string & path
) const {
@ -139,27 +122,31 @@ void GeometryCompressor::SerializeInternalVector(
}
void GeometryCompressor::CompressEdge(
const EdgeID surviving_edge_id,
const EdgeID removed_edge_id,
const EdgeID edge_id_1,
const EdgeID edge_id_2,
const NodeID via_node_id,
const EdgeWeight weight1//,
// const EdgeWeight weight2
const NodeID target_node_id,
const EdgeWeight weight1,
const EdgeWeight weight2
) {
BOOST_ASSERT( SPECIAL_EDGEID != surviving_edge_id );
BOOST_ASSERT( SPECIAL_NODEID != removed_edge_id );
BOOST_ASSERT( SPECIAL_EDGEID != edge_id_1 );
BOOST_ASSERT( SPECIAL_EDGEID != edge_id_2 );
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() != weight2 );
// append list of removed edge_id plus via node to surviving edge id:
// <surv_1, .. , surv_n, via_node_id, rem_1, .. rem_n
//
// General scheme:
// 1. append via node id to list of surviving_edge_id
// 2. find list for removed_edge_id, if yes add all elements and delete it
// 1. append via node id to list of edge_id_1
// 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
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
if( 0 == m_free_list.size() ) {
@ -169,60 +156,57 @@ void GeometryCompressor::CompressEdge(
}
BOOST_ASSERT( !m_free_list.empty() );
// 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();
}
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;
BOOST_ASSERT( surving_list_id < m_compressed_geometries.size() );
const unsigned edge_bucket_id1 = m_edge_id_to_list_index_map[edge_id_1];
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];
BOOST_ASSERT(
surviving_geometry_list.empty() ||
( via_node_id != surviving_geometry_list.back().first )
);
std::vector<CompressedNode> & edge_bucket_list1 = m_compressed_geometries[edge_bucket_id1];
if(surviving_edge_id == 0) {
if( 0 == edge_id_1 ) {
SimpleLogger().Write(logDEBUG) << "adding via " << via_node_id << ", w: " << weight1;
}
surviving_geometry_list.push_back( std::make_pair(via_node_id, weight1) );
BOOST_ASSERT( 0 < surviving_geometry_list.size() );
BOOST_ASSERT( !surviving_geometry_list.empty() );
if( edge_bucket_list1.empty() ) {
edge_bucket_list1.push_back( std::make_pair(via_node_id, weight1) );
}
// Find any existing list for removed_edge_id
typename boost::unordered_map<EdgeID, unsigned>::const_iterator remove_list_iterator;
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 ) {
const unsigned list_to_remove_index = remove_list_iterator->second;
BOOST_ASSERT( list_to_remove_index == GetPositionForID(removed_edge_id));
BOOST_ASSERT( 0 < edge_bucket_list1.size() );
BOOST_ASSERT( !edge_bucket_list1.empty() );
if( HasEntryForID(edge_id_2) ) {
// second edge is not atomic anymore
const unsigned list_to_remove_index = GetPositionForID(edge_id_2);
BOOST_ASSERT( list_to_remove_index < m_compressed_geometries.size() );
std::vector<CompressedNode> & remove_geometry_list = m_compressed_geometries[list_to_remove_index];
if(surviving_edge_id == 0) {
std::vector<CompressedNode> & edge_bucket_list2 = m_compressed_geometries[list_to_remove_index];
if( 0 == edge_id_1 ) {
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;
}
}
// found an existing list, append it to the list of surviving_edge_id
surviving_geometry_list.insert(
surviving_geometry_list.end(),
remove_geometry_list.begin(),
remove_geometry_list.end()
// found an existing list, append it to the list of edge_id_1
edge_bucket_list1.insert(
edge_bucket_list1.end(),
edge_bucket_list2.begin(),
edge_bucket_list2.end()
);
//remove the list of removed_edge_id
m_edge_id_to_list_index_map.erase(remove_list_iterator);
BOOST_ASSERT( m_edge_id_to_list_index_map.end() == m_edge_id_to_list_index_map.find(removed_edge_id) );
remove_geometry_list.clear();
BOOST_ASSERT( 0 == remove_geometry_list.size() );
//remove the list of edge_id_2
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(edge_id_2) );
edge_bucket_list2.clear();
BOOST_ASSERT( 0 == edge_bucket_list2.size() );
m_free_list.push_back(list_to_remove_index);
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();
void CompressEdge(
const EdgeID first_edge_id,
const EdgeID second_edge_id,
const EdgeID surviving_edge_id,
const EdgeID removed_edge_id,
const NodeID via_node_id,
const EdgeWeight weight1//,
// const EdgeWeight weight2
const NodeID target_node,
const EdgeWeight weight1,
const EdgeWeight weight2
);
void AddLastViaNodeIDToCompressedEdge(
const EdgeID edge_id,
const NodeID node_id,
const EdgeWeight weight
);
// void AddLastViaNodeIDToCompressedEdge(
// const EdgeID edge_id,
// const NodeID node_id,
// const EdgeWeight weight
// );
bool HasEntryForID(const EdgeID edge_id) const;
void PrintStatistics() const;
void SerializeInternalVector(const std::string & path) const;