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

correctly unpacking the first segment

Browse Source
This commit is contained in:
Dennis Luxen 2014-02-27 19:49:53 +01:00
parent a0bddab169
commit 874c579f86
7 changed files with 156 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

211
Contractor/EdgeBasedGraphFactory.cpp
View File

@ -299,53 +299,29 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
// find forward edge id and // find forward edge id and
// const EdgeID e1 = m_node_based_graph->FindEdge(u, v); // const EdgeID e1 = m_node_based_graph->FindEdge(u, v);
BOOST_ASSERT( e1 != std::numeric_limits<unsigned>::max() ); BOOST_ASSERT( e1 != SPECIAL_EDGEID );
const EdgeData & forward_data = m_node_based_graph->GetEdgeData(e1); const EdgeData & forward_data = m_node_based_graph->GetEdgeData(e1);
if( forward_data.edgeBasedNodeID == std::numeric_limits<unsigned>::max() ) {
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() << 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 << "," <<
// m_node_info_list[u].lon << " - " <<
// m_node_info_list[v].lat << "," <<
// m_node_info_list[v].lon;
return;
}
BOOST_ASSERT( forward_data.forward );
// 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 #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(logWARNING) << "Did not find edge (" << v << "," << u << ")";
} }
#endif #endif
BOOST_ASSERT( e2 != std::numeric_limits<unsigned>::max() ); BOOST_ASSERT( e2 != SPECIAL_EDGEID );
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);
// if( forward_data.forward == reverse_data.forward && forward_data.forward != forward_data.backward ) { if(
// SimpleLogger().Write(logDEBUG) << "flags on edge (" << u << "," << v << "), e1: " << e1 << ", e2: " << e2; forward_data.edgeBasedNodeID == SPECIAL_NODEID &&
// SimpleLogger().Write(logDEBUG) << "fwd-fwd: " << (forward_data.forward ? "y" : "n"); reverse_data.edgeBasedNodeID == SPECIAL_NODEID
// SimpleLogger().Write(logDEBUG) << "fwd-rev: " << (forward_data.backward ? "y": "n"); ) {
// SimpleLogger().Write(logDEBUG) << "rev-fwd: " << (reverse_data.forward ? "y" : "n"); return;
// SimpleLogger().Write(logDEBUG) << "rev-rev: " << (reverse_data.backward ? "y": "n"); }
// SimpleLogger().Write(logDEBUG) << "outgoing edges to ";
// for(EdgeIterator id = m_node_based_graph->BeginEdges(v); id < m_node_based_graph->EndEdges(v); ++id) { BOOST_ASSERT( m_geometry_compressor.HasEntryForID(e1) == m_geometry_compressor.HasEntryForID(e2) );
// SimpleLogger().Write(logDEBUG) << " id: " << id << ", edge (" << v << "," << m_node_based_graph->GetTarget(id) << ")";
// }
// BOOST_ASSERT( reverse_data.edgeBasedNodeID != std::numeric_limits<unsigned>::max() );
// } else {
// BOOST_ASSERT( reverse_data.edgeBasedNodeID == std::numeric_limits<unsigned>::max() );
// }
if( m_geometry_compressor.HasEntryForID(e1) ) { if( m_geometry_compressor.HasEntryForID(e1) ) {
BOOST_ASSERT( m_geometry_compressor.HasEntryForID(e2) ); BOOST_ASSERT( m_geometry_compressor.HasEntryForID(e2) );
@ -356,82 +332,41 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
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() );
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; // BOOST_FOREACH(const GeometryCompressor::CompressedNode & geometry_node, forward_geometry) {
// if( 1 == e1 ) { // const NodeID fwd_end_node = geometry_node.first;
// SimpleLogger().Write(logDEBUG) << "fwd edge id: " << e1; // const EdgeWeight fwd_weight = geometry_node.second;
// fwd_sum_of_weights += fwd_weight;
// fwd_start_node = fwd_end_node;
// } // }
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; // BOOST_ASSERT( forward_data.distance == fwd_sum_of_weights );
fwd_sum_of_weights += fwd_weight;
// if( 1 == e1 ) { // int rev_sum_of_weights = 0;
// SimpleLogger().Write(logDEBUG) << "fwd-edge (" << fwd_start_node << "," << fwd_end_node << "), w: " << fwd_weight; // NodeID rev_start_node = v;
// } // BOOST_FOREACH(const GeometryCompressor::CompressedNode & geometry_node, reverse_geometry) {
fwd_start_node = fwd_end_node; // const NodeID rev_end_node = geometry_node.first;
} // const EdgeWeight rev_weight = geometry_node.second;
// if( 1 == e1 ) {
// SimpleLogger().Write(logDEBUG) << "fwd-edge (" << fwd_start_node << "," << v << "), w: " << (forward_data.distance - fwd_sum_of_weights); // rev_sum_of_weights += rev_weight;
// rev_start_node = rev_end_node;
// } // }
// 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;
// if( 1 == e1 ) { // BOOST_ASSERT( reverse_data.distance == rev_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);
// }
BOOST_ASSERT( forward_data.distance == fwd_sum_of_weights );
// reconstruct bidirectional edge with individual weights and put each into the NN index
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) {
const NodeID rev_end_node = geometry_node.first;
const EdgeWeight rev_weight = 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 += rev_weight;
// if( 1 == e1 ) {
// SimpleLogger().Write(logDEBUG) << "Edge (" << rev_start_node << "," << rev_end_node << "), w: " << rev_weight;
// }
rev_start_node = rev_end_node;
}
// 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( 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> forward_dist_prefix_sum( forward_geometry.size() );
std::vector<int> reverse_dist_prefix_sum( reverse_geometry.size() ); std::vector<int> reverse_dist_prefix_sum( reverse_geometry.size() );
//quick'n'dirty prefix sum as std::partial_sum needs addtional casts // quick'n'dirty prefix sum as std::partial_sum needs addtional casts
// SimpleLogger().Write(logDEBUG) << "Prefix sums of edge " << e1 << ", w: " << reverse_data.distance; // SimpleLogger().Write(logDEBUG) << "Prefix sums of edge " << e1 << ", w: " << reverse_data.distance;
int temp_sum = 0; int temp_sum = 0;
for( unsigned i = 0; i < forward_geometry.size(); ++i ) { for( unsigned i = 0; i < forward_geometry.size(); ++i ) {
temp_sum += forward_geometry[i].second; temp_sum += forward_geometry[i].second;
BOOST_ASSERT( forward_data.distance >= temp_sum ); BOOST_ASSERT( forward_data.distance >= temp_sum );
forward_dist_prefix_sum[i] = 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 ); BOOST_ASSERT( forward_data.distance == temp_sum );
temp_sum = 0; temp_sum = 0;
@ -439,7 +374,6 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
temp_sum += reverse_geometry[i].second; temp_sum += reverse_geometry[i].second;
BOOST_ASSERT( reverse_data.distance >= temp_sum ); BOOST_ASSERT( reverse_data.distance >= temp_sum );
reverse_dist_prefix_sum[i] = 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( reverse_data.distance == temp_sum );
@ -453,11 +387,7 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
BOOST_ASSERT( current_edge_start_coordinate_id == reverse_geometry[geometry_size-1-i].first ); BOOST_ASSERT( current_edge_start_coordinate_id == reverse_geometry[geometry_size-1-i].first );
const NodeID current_edge_target_coordinate_id = forward_geometry[i].first; const NodeID current_edge_target_coordinate_id = forward_geometry[i].first;
// SimpleLogger().Write() << "adding edge (" << current_edge_start_coordinate_id << "," << forward_geometry[i].first << ") "; // build edges
// 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( m_edge_based_node_list.push_back(
EdgeBasedNode( EdgeBasedNode(
forward_data.edgeBasedNodeID, forward_data.edgeBasedNodeID,
@ -471,7 +401,8 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
reverse_dist_prefix_sum[geometry_size-1-i], reverse_dist_prefix_sum[geometry_size-1-i],
i, i,
geometry_size-1-i, geometry_size-1-i,
belongs_to_tiny_cc belongs_to_tiny_cc,
true
) )
); );
current_edge_start_coordinate_id = current_edge_target_coordinate_id; current_edge_start_coordinate_id = current_edge_target_coordinate_id;
@ -511,6 +442,11 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
// BOOST_ASSERT( forward_data.forward == reverse_data.backward ); // BOOST_ASSERT( forward_data.forward == reverse_data.backward );
// BOOST_ASSERT( reverse_data.forward == forward_data.backward ); // BOOST_ASSERT( reverse_data.forward == forward_data.backward );
BOOST_ASSERT(
forward_data.edgeBasedNodeID != SPECIAL_NODEID ||
reverse_data.edgeBasedNodeID != SPECIAL_NODEID
);
//TODO: emplace_back with C++11 //TODO: emplace_back with C++11
m_edge_based_node_list.push_back( m_edge_based_node_list.push_back(
EdgeBasedNode( EdgeBasedNode(
@ -525,7 +461,8 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
0, 0,
0, 0,
0, 0,
belongs_to_tiny_cc belongs_to_tiny_cc,
false
) )
); );
BOOST_ASSERT( !m_edge_based_node_list.back().IsCompressed() ); BOOST_ASSERT( !m_edge_based_node_list.back().IsCompressed() );
@ -641,8 +578,6 @@ void EdgeBasedGraphFactory::Run(
FixupStartingTurnRestriction( w, v, u ); FixupStartingTurnRestriction( w, v, u );
FixupArrivingTurnRestriction( w, v, u ); FixupArrivingTurnRestriction( w, v, u );
// const int reverse_weight2 = rev_edge_data2.distance;
// store compressed geometry in container // store compressed geometry in container
m_geometry_compressor.CompressEdge( m_geometry_compressor.CompressEdge(
forward_e1, forward_e1,
@ -686,7 +621,6 @@ void EdgeBasedGraphFactory::Run(
for(EdgeIterator current_edge = m_node_based_graph->BeginEdges(current_node); current_edge < m_node_based_graph->EndEdges(current_node); ++current_edge) { for(EdgeIterator current_edge = m_node_based_graph->BeginEdges(current_node); current_edge < m_node_based_graph->EndEdges(current_node); ++current_edge) {
EdgeData & edge_data = m_node_based_graph->GetEdgeData(current_edge); EdgeData & edge_data = m_node_based_graph->GetEdgeData(current_edge);
if( !edge_data.forward ) { if( !edge_data.forward ) {
// SimpleLogger().Write(logDEBUG) << "skipped edge (" << source << "," << target << ")=[" << current_edge_id << "]";
continue; continue;
} }
@ -722,8 +656,7 @@ void EdgeBasedGraphFactory::Run(
SimpleLogger().Write() << SimpleLogger().Write() <<
"identified: " << component_index_size.size() << " many components"; "identified: " << component_index_size.size() << " many components";
SimpleLogger().Write() << SimpleLogger().Write() << "generating edge-expanded nodes";
"generating edge-expanded nodes";
p.reinit(m_node_based_graph->GetNumberOfNodes()); p.reinit(m_node_based_graph->GetNumberOfNodes());
@ -737,22 +670,24 @@ void EdgeBasedGraphFactory::Run(
BOOST_ASSERT( u < m_node_based_graph->GetNumberOfNodes() ); BOOST_ASSERT( u < m_node_based_graph->GetNumberOfNodes() );
p.printIncrement(); p.printIncrement();
for( for(
EdgeIterator e1 = m_node_based_graph->BeginEdges(u), EdgeID e1 = m_node_based_graph->BeginEdges(u),
last_edge = m_node_based_graph->EndEdges(u); last_edge = m_node_based_graph->EndEdges(u);
e1 < last_edge; e1 < last_edge;
++e1 ++e1
) { ) {
const EdgeData & edge_data = m_node_based_graph->GetEdgeData(e1); const EdgeData & edge_data = m_node_based_graph->GetEdgeData(e1);
if( edge_data.edgeBasedNodeID == std::numeric_limits<unsigned>::max() ) { if( edge_data.edgeBasedNodeID == SPECIAL_NODEID ) {
continue; // continue;
} }
BOOST_ASSERT( e1 != std::numeric_limits<unsigned>::max() ); BOOST_ASSERT( e1 != SPECIAL_EDGEID );
NodeIterator v = m_node_based_graph->GetTarget(e1); const NodeID v = m_node_based_graph->GetTarget(e1);
BOOST_ASSERT( std::numeric_limits<unsigned>::max() != v );
BOOST_ASSERT( SPECIAL_NODEID != v );
// pick only every other edge // pick only every other edge
if( u > v ) { if( u > v ) {
continue; continue;
} }
// BOOST_ASSERT( u < v ); // BOOST_ASSERT( u < v );
BOOST_ASSERT( edge_data.type != SHRT_MAX ); BOOST_ASSERT( edge_data.type != SHRT_MAX );
@ -764,40 +699,10 @@ void EdgeBasedGraphFactory::Run(
); );
const bool component_is_tiny = ( size_of_component < 1000 ); const bool component_is_tiny = ( size_of_component < 1000 );
InsertEdgeBasedNode( u, v, e1, component_is_tiny ); InsertEdgeBasedNode( u, v, e1, component_is_tiny );
} }
} }
// for(
// NodeIterator u = 0, end = m_node_based_graph->GetNumberOfNodes();
// u < end;
// ++u
// ) {
// BOOST_ASSERT( u != std::numeric_limits<unsigned>::max() );
// BOOST_ASSERT( u < m_node_based_graph->GetNumberOfNodes() );
// p.printIncrement();
// for(
// EdgeIterator e1 = m_node_based_graph->BeginEdges(u),
// last_edge = m_node_based_graph->EndEdges(u);
// e1 < last_edge;
// ++e1
// ) {
// BOOST_ASSERT( e1 != std::numeric_limits<unsigned>::max() );
// NodeIterator v = m_node_based_graph->GetTarget(e1);
// EdgeIterator e2 = m_node_based_graph->FindEdge(u, v);
// BOOST_ASSERT( e2 != m_node_based_graph->EndEdges(v) );
// BOOST_ASSERT( e1 == e2 );
// const EdgeData & data = m_node_based_graph->GetEdgeData(e1);
// if( data.forward ) {
// BOOST_ASSERT( data.edgeBasedNodeID != std::numeric_limits<unsigned>::max() );
// }
// }
// }
m_number_of_edge_based_nodes = numbered_edges_count; m_number_of_edge_based_nodes = numbered_edges_count;
SimpleLogger().Write() << "Generated " << m_edge_based_node_list.size() << SimpleLogger().Write() << "Generated " << m_edge_based_node_list.size() <<
@ -855,8 +760,9 @@ void EdgeBasedGraphFactory::Run(
continue; continue;
} }
const NodeIterator w = m_node_based_graph->GetTarget(e2); const NodeIterator w = m_node_based_graph->GetTarget(e2);
if( if(
to_node_of_only_restriction != std::numeric_limits<unsigned>::max() && to_node_of_only_restriction != SPECIAL_NODEID &&
w != to_node_of_only_restriction w != to_node_of_only_restriction
) { ) {
//We are at an only_-restriction but not at the right turn. //We are at an only_-restriction but not at the right turn.
@ -880,7 +786,7 @@ void EdgeBasedGraphFactory::Run(
//at the end of a dead-end street //at the end of a dead-end street
if ( if (
CheckIfTurnIsRestricted(u, v, w) && CheckIfTurnIsRestricted(u, v, w) &&
(to_node_of_only_restriction == std::numeric_limits<unsigned>::max()) && (to_node_of_only_restriction == SPECIAL_NODEID) &&
(w != to_node_of_only_restriction) (w != to_node_of_only_restriction)
) { ) {
++restricted_turns_counter; ++restricted_turns_counter;
@ -916,12 +822,9 @@ void EdgeBasedGraphFactory::Run(
distance += turn_penalty; distance += turn_penalty;
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);
if ( 0 == m_geometry_compressor.GetPositionForID(e1) ) {
SimpleLogger().Write(logDEBUG) << "e1: " << e1 << " is zero with via node: " << v;
}
} }
original_edge_data_vector.push_back( original_edge_data_vector.push_back(
@ -932,6 +835,7 @@ void EdgeBasedGraphFactory::Run(
edge_is_compressed edge_is_compressed
) )
); );
++original_edges_counter; ++original_edges_counter;
if(original_edge_data_vector.size() > 100000) { if(original_edge_data_vector.size() > 100000) {
@ -941,6 +845,9 @@ void EdgeBasedGraphFactory::Run(
); );
} }
BOOST_ASSERT( SPECIAL_NODEID != edge_data1.edgeBasedNodeID );
BOOST_ASSERT( SPECIAL_NODEID != edge_data2.edgeBasedNodeID );
m_edge_based_edge_list.push_back( m_edge_based_edge_list.push_back(
EdgeBasedEdge( EdgeBasedEdge(
edge_data1.edgeBasedNodeID, edge_data1.edgeBasedNodeID,

10
Contractor/GeometryCompressor.cpp
View File

@ -166,10 +166,6 @@ void GeometryCompressor::CompressEdge(
std::vector<CompressedNode> & edge_bucket_list1 = m_compressed_geometries[edge_bucket_id1]; std::vector<CompressedNode> & edge_bucket_list1 = m_compressed_geometries[edge_bucket_id1];
if( 0 == edge_id_1 ) {
SimpleLogger().Write(logDEBUG) << "adding via " << via_node_id << ", w: " << weight1;
}
if( edge_bucket_list1.empty() ) { if( edge_bucket_list1.empty() ) {
edge_bucket_list1.push_back( std::make_pair(via_node_id, weight1) ); edge_bucket_list1.push_back( std::make_pair(via_node_id, weight1) );
} }
@ -183,12 +179,6 @@ void GeometryCompressor::CompressEdge(
BOOST_ASSERT( list_to_remove_index < m_compressed_geometries.size() ); BOOST_ASSERT( list_to_remove_index < m_compressed_geometries.size() );
std::vector<CompressedNode> & edge_bucket_list2 = m_compressed_geometries[list_to_remove_index]; 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, edge_bucket_list2) {
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 edge_id_1
edge_bucket_list1.insert( edge_bucket_list1.insert(

2
DataStructures/Coordinate.cpp
View File

@ -174,5 +174,5 @@ void FixedPointCoordinate::convertInternalReversedCoordinateToString(
} }
void FixedPointCoordinate::Output(std::ostream & out) const {//, FixedPointCoordinate & c) { void FixedPointCoordinate::Output(std::ostream & out) const {//, FixedPointCoordinate & c) {
out << "(" << lat << "," << lon << ")"; out << "(" << lat/COORDINATE_PRECISION << "," << lon/COORDINATE_PRECISION << ")";
} }

35
DataStructures/EdgeBasedNode.h
View File

@ -23,11 +23,12 @@ struct EdgeBasedNode {
forward_offset(0), forward_offset(0),
reverse_offset(0), reverse_offset(0),
fwd_segment_position( std::numeric_limits<unsigned short>::max() ), fwd_segment_position( std::numeric_limits<unsigned short>::max() ),
rev_segment_position( std::numeric_limits<unsigned short>::max() >> 1 ), rev_segment_position( std::numeric_limits<unsigned short>::max() >> 2 ),
belongsToTinyComponent(false) belongsToTinyComponent(false),
is_compressed(false)
{ } { }
EdgeBasedNode( explicit EdgeBasedNode(
NodeID forward_edge_based_node_id, NodeID forward_edge_based_node_id,
NodeID reverse_edge_based_node_id, NodeID reverse_edge_based_node_id,
NodeID u, NodeID u,
@ -39,7 +40,8 @@ struct EdgeBasedNode {
int reverse_offset, int reverse_offset,
unsigned short fwd_segment_position, unsigned short fwd_segment_position,
unsigned short rev_segment_position, unsigned short rev_segment_position,
bool belongsToTinyComponent bool belongsToTinyComponent,
bool is_compressed
) : ) :
forward_edge_based_node_id(forward_edge_based_node_id), forward_edge_based_node_id(forward_edge_based_node_id),
reverse_edge_based_node_id(reverse_edge_based_node_id), reverse_edge_based_node_id(reverse_edge_based_node_id),
@ -52,10 +54,23 @@ struct EdgeBasedNode {
reverse_offset(reverse_offset), reverse_offset(reverse_offset),
fwd_segment_position(fwd_segment_position), fwd_segment_position(fwd_segment_position),
rev_segment_position(rev_segment_position), rev_segment_position(rev_segment_position),
belongsToTinyComponent(belongsToTinyComponent) belongsToTinyComponent(belongsToTinyComponent),
{ } is_compressed(is_compressed)
// Computes: {
// - the distance from the given query location to nearest point on this edge (and returns it) BOOST_ASSERT(
( forward_edge_based_node_id != SPECIAL_NODEID ) ||
( reverse_edge_based_node_id != SPECIAL_NODEID )
);
// if( forward_edge_based_node_id == SPECIAL_NODEID ) {
// using namespace std;
// swap( forward_edge_based_node_id, reverse_edge_based_node_id );
// swap( u, v );
// swap( forward_weight, reverse_weight );
// swap( forward_offset, reverse_offset );
// swap( fwd_segment_position, rev_segment_position );
// }
}
inline static double ComputePerpendicularDistance( inline static double ComputePerpendicularDistance(
const FixedPointCoordinate & coord_a, const FixedPointCoordinate & coord_a,
const FixedPointCoordinate & coord_b, const FixedPointCoordinate & coord_b,
@ -134,7 +149,7 @@ struct EdgeBasedNode {
} }
bool IsCompressed() { bool IsCompressed() {
return (fwd_segment_position + rev_segment_position) != 0; return is_compressed;
} }
// Returns the midpoint of the underlying edge. // Returns the midpoint of the underlying edge.
@ -152,7 +167,7 @@ struct EdgeBasedNode {
int forward_offset; int forward_offset;
int reverse_offset; int reverse_offset;
unsigned short fwd_segment_position; unsigned short fwd_segment_position;
unsigned short rev_segment_position:15; unsigned short rev_segment_position:14; //TODO: not actually needed!
bool belongsToTinyComponent:1; bool belongsToTinyComponent:1;
NodeID name_id; NodeID name_id;

10
DataStructures/StaticRTree.h
View File

@ -683,11 +683,11 @@ public:
BOOST_ASSERT( 0. <= current_perpendicular_distance ); BOOST_ASSERT( 0. <= current_perpendicular_distance );
if( if(
( current_perpendicular_distance < min_dist ) //&& ( current_perpendicular_distance < min_dist ) &&
// !DoubleEpsilonCompare( !DoubleEpsilonCompare(
// current_perpendicular_distance, current_perpendicular_distance,
// min_dist min_dist
// ) )
) { //found a new minimum ) { //found a new minimum
min_dist = current_perpendicular_distance; min_dist = current_perpendicular_distance;
result_phantom_node.forward_node_id = current_edge.forward_edge_based_node_id; result_phantom_node.forward_node_id = current_edge.forward_edge_based_node_id;

2
RoutingAlgorithms/AlternativePathRouting.h
View File

@ -294,7 +294,7 @@ public:
super::UnpackPath( super::UnpackPath(
packed_shortest_path, packed_shortest_path,
phantom_node_pair.startPhantom.fwd_segment_position, phantom_node_pair.startPhantom.fwd_segment_position,
(packed_shortest_path.front() == phantom_node_pair.startPhantom.forward_node_id), (packed_shortest_path.front() != phantom_node_pair.startPhantom.forward_node_id),
phantom_node_pair.targetPhantom.fwd_segment_position,//( packed_forward_path.back() == phantom_node_pair.targetPhantom.forward_node_id ? 1 : -1 )*phantom_node_pair.targetPhantom.fwd_segment_position, phantom_node_pair.targetPhantom.fwd_segment_position,//( packed_forward_path.back() == phantom_node_pair.targetPhantom.forward_node_id ? 1 : -1 )*phantom_node_pair.targetPhantom.fwd_segment_position,
raw_route_data.unpacked_path_segments.front() raw_route_data.unpacked_path_segments.front()
); );

154
RoutingAlgorithms/BasicRoutingInterface.h
View File

@ -69,7 +69,7 @@ public:
) const { ) const {
const NodeID node = forward_heap.DeleteMin(); const NodeID node = forward_heap.DeleteMin();
const int distance = forward_heap.GetKey(node); const int distance = forward_heap.GetKey(node);
//SimpleLogger().Write() << "Settled (" << forward_heap.GetData( node ).parent << "," << node << ")=" << distance; SimpleLogger().Write() << (forward_direction ? "fwd" : "rev") << " settled (" << forward_heap.GetData( node ).parent << "," << node << ")=" << distance;
if(reverse_heap.WasInserted(node) ){ if(reverse_heap.WasInserted(node) ){
const int new_distance = reverse_heap.GetKey(node) + distance; const int new_distance = reverse_heap.GetKey(node) + distance;
if(new_distance < *upper_bound ){ if(new_distance < *upper_bound ){
@ -143,13 +143,6 @@ public:
int rev_index_offset, int rev_index_offset,
std::vector<PathData> & unpacked_path std::vector<PathData> & unpacked_path
) const { ) const {
// SimpleLogger().Write(logDEBUG) << "unpacking path";
// for(unsigned i = 0; i < packed_path.size(); ++i) {
// std::cout << packed_path[i] << " ";
// }
// SimpleLogger().Write() << "starting unpack";
const unsigned packed_path_size = packed_path.size(); const unsigned packed_path_size = packed_path.size();
std::stack<std::pair<NodeID, NodeID> > recursion_stack; std::stack<std::pair<NodeID, NodeID> > recursion_stack;
@ -162,17 +155,50 @@ public:
std::pair<NodeID, NodeID> edge; std::pair<NodeID, NodeID> edge;
while(!recursion_stack.empty()) { while(!recursion_stack.empty()) {
bool segment_reversed = false; // bool segment_reversed = false;
edge = recursion_stack.top(); edge = recursion_stack.top();
recursion_stack.pop(); recursion_stack.pop();
EdgeID smaller_edge_id = facade->FindEdgeIndicateIfReverse( // facade->FindEdge does not suffice here in case of shortcuts.
edge.first, // The above explanation unclear? Think!
edge.second, EdgeID smaller_edge_id = SPECIAL_EDGEID;
segment_reversed int edge_weight = INT_MAX;
); for(
EdgeID edge_id = facade->BeginEdges(edge.first);
edge_id < facade->EndEdges(edge.first);
++edge_id
){
const int weight = facade->GetEdgeData(edge_id).distance;
if(
(facade->GetTarget(edge_id) == edge.second) &&
(weight < edge_weight) &&
facade->GetEdgeData(edge_id).forward
){
smaller_edge_id = edge_id;
edge_weight = weight;
}
}
if( SPECIAL_EDGEID == smaller_edge_id ){
for(
EdgeID edge_id = facade->BeginEdges(edge.second);
edge_id < facade->EndEdges(edge.second);
++edge_id
){
const int weight = facade->GetEdgeData(edge_id).distance;
if(
(facade->GetTarget(edge_id) == edge.first) &&
(weight < edge_weight) &&
facade->GetEdgeData(edge_id).backward
){
smaller_edge_id = edge_id;
edge_weight = weight;
}
}
}
BOOST_ASSERT_MSG(edge_weight != INT_MAX, "edge id invalid");
BOOST_ASSERT( SPECIAL_EDGEID != smaller_edge_id );
BOOST_ASSERT( facade->EndEdges(edge.first) != smaller_edge_id );
const EdgeData& ed = facade->GetEdgeData(smaller_edge_id); const EdgeData& ed = facade->GetEdgeData(smaller_edge_id);
if( ed.shortcut ) {//unpack if( ed.shortcut ) {//unpack
@ -185,7 +211,6 @@ public:
unsigned name_index = facade->GetNameIndexFromEdgeID(ed.id); unsigned name_index = facade->GetNameIndexFromEdgeID(ed.id);
const TurnInstruction turn_instruction = facade->GetTurnInstructionForEdgeID(ed.id); const TurnInstruction turn_instruction = facade->GetTurnInstructionForEdgeID(ed.id);
//TODO: refactor to iterate over a result vector in both cases
if ( !facade->EdgeIsCompressed(ed.id) ){ if ( !facade->EdgeIsCompressed(ed.id) ){
BOOST_ASSERT( !facade->EdgeIsCompressed(ed.id) ); BOOST_ASSERT( !facade->EdgeIsCompressed(ed.id) );
unpacked_path.push_back( unpacked_path.push_back(
@ -200,81 +225,27 @@ public:
std::vector<unsigned> id_vector; std::vector<unsigned> id_vector;
facade->GetUncompressedGeometry(ed.id, id_vector); facade->GetUncompressedGeometry(ed.id, id_vector);
const int start_index = ( unpacked_path.empty() ? ( ( start_traversed_in_reverse ) ? id_vector.size() - fwd_index_offset - 1 : fwd_index_offset ) : 0 );
const int end_index = id_vector.size();
//TODO use only a single for loop BOOST_ASSERT( start_index >= 0 );
if( unpacked_path.empty() ) { BOOST_ASSERT( start_index <= end_index );
// // SimpleLogger().Write(logDEBUG) << "1st node in packed path: " << packed_path.front() << ", edge (" << edge.first << "," << edge.second << ")"; for(
// // SimpleLogger().Write(logDEBUG) << "REVERSED1: " << ( facade->GetTarget(smaller_edge_id) != edge.second ? "y" : "n" ); unsigned i = start_index;
// // SimpleLogger().Write(logDEBUG) << "REVERSED2: " << ( facade->GetTarget(smaller_edge_id) != edge.first ? "y" : "n" ); i < end_index;
// SimpleLogger().Write(logDEBUG) << "segment_reversed: " << ( segment_reversed ? "y" : "n" ); ++i
// // SimpleLogger().Write(logDEBUG) << "target of edge: " << facade->GetTarget(smaller_edge_id); ) {
// // SimpleLogger().Write(logDEBUG) << "first geometry: " << id_vector.front() << ", last geometry: " << id_vector.back(); unpacked_path.push_back(
PathData(
const bool edge_is_reversed = (!ed.forward && ed.backward); id_vector[i],
SimpleLogger().Write(logDEBUG) << "fwd offset: " << fwd_index_offset; name_index,
SimpleLogger().Write(logDEBUG) << "rev offset: " << rev_index_offset; TurnInstructionsClass::NoTurn,
SimpleLogger().Write(logDEBUG) << "start_traversed_in_reverse: " << ( start_traversed_in_reverse ? "y" : "n" ); 0
SimpleLogger().Write(logDEBUG) << "edge_is_reversed: " << ( edge_is_reversed ? "y" : "n" ); )
);
// if( edge_is_reversed ) {
// SimpleLogger().Write(logDEBUG) << "reversing geometry";
// std::reverse( id_vector.begin(), id_vector.end() );
// fwd_index_offset = id_vector.size() - (1+fwd_index_offset);
// SimpleLogger().Write() << "new fwd offset: " << fwd_index_offset;
// }
SimpleLogger().Write(logDEBUG) << "edge data fwd: " << (ed.forward ? "y": "n") << ", reverse: " << (ed.backward ? "y" : "n" );
SimpleLogger().Write() << "Edge " << ed.id << "=(" << edge.first << "," << edge.second << ") is compressed";
SimpleLogger().Write(logDEBUG) << "packed ids: ";
BOOST_FOREACH(unsigned number, id_vector) {
SimpleLogger().Write() << "[" << number << "] " << facade->GetCoordinateOfNode(number);
}
int start_index = ( ( start_traversed_in_reverse ) ? 0 : id_vector.size() - fwd_index_offset );
int end_index = ( ( start_traversed_in_reverse ) ? id_vector.size() + 1 - fwd_index_offset : id_vector.size() );
if( edge_is_reversed ) {
start_index = ( ( !start_traversed_in_reverse ) ? id_vector.size() - fwd_index_offset - 1: fwd_index_offset );
end_index = ( ( !start_traversed_in_reverse ) ? id_vector.size() : id_vector.size() + 1 - fwd_index_offset );
}
// BOOST_ASSERT( start_index >= 0 );
// // BOOST_ASSERT( start_index <= end_index );
SimpleLogger().Write(logDEBUG) << "geometry count: " << id_vector.size() << ", fetching[" << start_index << "..." << end_index << "]";
for(
unsigned i = start_index;
i != end_index;
(start_index > end_index) ? --i : ++i
) {
SimpleLogger().Write(logDEBUG) << "[" << i << "]pushing id: " << id_vector[i];
unpacked_path.push_back(
PathData(
id_vector[i],
name_index,
TurnInstructionsClass::NoTurn,
0
)
);
}
} else {
BOOST_FOREACH(const unsigned coordinate_id, id_vector){
// SimpleLogger().Write(logDEBUG) << "pushing id: " << coordinate_id;
unpacked_path.push_back(
PathData(
coordinate_id,
name_index,
TurnInstructionsClass::NoTurn,
0
)
);
}
unpacked_path.back().turnInstruction = turn_instruction;
unpacked_path.back().durationOfSegment = ed.distance;
} }
unpacked_path.back().turnInstruction = turn_instruction;
unpacked_path.back().durationOfSegment = ed.distance;
} }
} }
} }
@ -368,6 +339,11 @@ public:
current_node_id = reverse_heap.GetData(current_node_id).parent; current_node_id = reverse_heap.GetData(current_node_id).parent;
packed_path.push_back(current_node_id); packed_path.push_back(current_node_id);
} }
BOOST_FOREACH(NodeID node, packed_path) {
SimpleLogger().Write(logDEBUG) << "node: " << node;
}
} }
//TODO: reorder parameters //TODO: reorder parameters