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

Generation of edge based graph fixed.

Browse Source
This commit is contained in:
DennisOSRM 2011-11-14 13:12:56 +01:00
parent afaca23f12
commit 34e4ead885
2 changed files with 79 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
Contractor/EdgeBasedGraphFactory.cpp
View File

@ -29,7 +29,8 @@
#include "../DataStructures/ExtractorStructs.h" #include "../DataStructures/ExtractorStructs.h"
template<> template<>
EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<Edge> & inputEdges, std::vector<_Restriction> & irs) : inputRestrictions(irs) { EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<NodeBasedEdge> & inputEdges, std::vector<_Restriction> & irs, std::vector<NodeInfo> & nI)
: inputRestrictions(irs), inputNodeInfoList(nI) {
#ifdef _GLIBCXX_PARALLEL #ifdef _GLIBCXX_PARALLEL
__gnu_parallel::sort(inputRestrictions.begin(), inputRestrictions.end(), CmpRestrictionByFrom); __gnu_parallel::sort(inputRestrictions.begin(), inputRestrictions.end(), CmpRestrictionByFrom);
@ -39,7 +40,7 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<Edge> & inpu
std::vector< _NodeBasedEdge > edges; std::vector< _NodeBasedEdge > edges;
edges.reserve( 2 * inputEdges.size() ); edges.reserve( 2 * inputEdges.size() );
for ( typename std::vector< Edge >::const_iterator i = inputEdges.begin(), e = inputEdges.end(); i != e; ++i ) { for ( typename std::vector< NodeBasedEdge >::const_iterator i = inputEdges.begin(), e = inputEdges.end(); i != e; ++i ) {
_NodeBasedEdge edge; _NodeBasedEdge edge;
edge.source = i->source(); edge.source = i->source();
edge.target = i->target(); edge.target = i->target();
@ -54,13 +55,13 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<Edge> & inpu
edge.data.type = i->type(); edge.data.type = i->type();
edge.data.forward = i->isForward(); edge.data.forward = i->isForward();
edge.data.backward = i->isBackward(); edge.data.backward = i->isBackward();
edge.data.newNodeID = edges.size(); edge.data.edgeBasedNodeID = edges.size();
edges.push_back( edge ); edges.push_back( edge );
std::swap( edge.source, edge.target ); std::swap( edge.source, edge.target );
if( edge.data.backward ) { if( edge.data.backward ) {
edge.data.forward = i->isBackward(); edge.data.forward = i->isBackward();
edge.data.backward = i->isForward(); edge.data.backward = i->isForward();
edge.data.newNodeID = edges.size(); edge.data.edgeBasedNodeID = edges.size();
edges.push_back( edge ); edges.push_back( edge );
} }
} }
@ -78,39 +79,30 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<Edge> & inpu
} }
template<> template<>
void EdgeBasedGraphFactory::GetEdges( std::vector< ImportEdge >& edges ) { void EdgeBasedGraphFactory::GetEdgeBasedEdges( std::vector< EdgeBasedEdge >& edges ) {
GUARANTEE(0 == edges.size(), "Vector passed to " << __FUNCTION__ << " is not empty"); GUARANTEE(0 == edges.size(), "Vector passed to " << __FUNCTION__ << " is not empty");
GUARANTEE(0 != edgeBasedEdges.size(), "No edges in edge based graph"); GUARANTEE(0 != edgeBasedEdges.size(), "No edges in edge based graph");
for ( unsigned edge = 0; edge < edgeBasedEdges.size(); ++edge ) { BOOST_FOREACH ( EdgeBasedEdge currentEdge, edgeBasedEdges) {
ImportEdge importEdge(edgeBasedEdges[edge].source, edgeBasedEdges[edge].target, edgeBasedEdges[edge].data.distance, edgeBasedEdges[edge].data.distance, true, false, edgeBasedEdges[edge].data.type); edges.push_back(currentEdge);
edges.push_back(importEdge);
} }
#ifdef _GLIBCXX_PARALLEL
__gnu_parallel::sort( edges.begin(), edges.end() );
#else
sort( edges.begin(), edges.end() );
#endif
} }
void EdgeBasedGraphFactory::GetEdgeBasedNodes( std::vector< EdgeBasedNode> & nodes) {
template< class NodeT> for(unsigned i = 0; i < edgeBasedNodes.size(); ++i)
void EdgeBasedGraphFactory::GetNodes( std::vector< NodeT> & nodes) { nodes.push_back(edgeBasedNodes[i]);
} }
void EdgeBasedGraphFactory::Run() { void EdgeBasedGraphFactory::Run() {
INFO("Generating Edge based representation of input data"); INFO("Generating Edge based representation of input data");
_edgeBasedGraph.reset(new _EdgeBasedDynamicGraph(_nodeBasedGraph->GetNumberOfEdges() ) ); _edgeBasedGraph.reset(new _EdgeBasedDynamicGraph(_nodeBasedGraph->GetNumberOfEdges() ) );
std::vector<_Restriction>::iterator restrictionIterator = inputRestrictions.begin(); std::vector<_Restriction>::iterator restrictionIterator = inputRestrictions.begin();
Percent p(_nodeBasedGraph->GetNumberOfNodes()); Percent p(_nodeBasedGraph->GetNumberOfNodes());
int numberOfResolvedRestrictions(0); int numberOfResolvedRestrictions(0);
int nodeBasedEdgeCounter(0); int nodeBasedEdgeCounter(0);
//Loop over all nodes u. Three nested loop look super-linear, but we are dealing with a number linear in the turns only. //Loop over all nodes u. Three nested loop look super-linear, but we are dealing with a number linear in the turns only.
for(_NodeBasedDynamicGraph::NodeIterator u = 0; u < _nodeBasedGraph->GetNumberOfNodes(); ++u ) { for(_NodeBasedDynamicGraph::NodeIterator u = 0; u < _nodeBasedGraph->GetNumberOfNodes(); ++u ) {
//loop over all adjacent edge (u,v) //loop over all adjacent edge (u,v)
@ -137,8 +129,17 @@ void EdgeBasedGraphFactory::Run() {
} }
if( !isTurnProhibited ) { //only add an edge if turn is not prohibited if( !isTurnProhibited ) { //only add an edge if turn is not prohibited
//new costs for edge based edge (e1, e2) = cost (e1) + tc(e1,e2) //new costs for edge based edge (e1, e2) = cost (e1) + tc(e1,e2)
_NodeBasedDynamicGraph::NodeIterator edgeBasedSource = _nodeBasedGraph->GetEdgeData(e1).newNodeID; const _NodeBasedDynamicGraph::NodeIterator edgeBasedSource = _nodeBasedGraph->GetEdgeData(e1).edgeBasedNodeID;
_NodeBasedDynamicGraph::NodeIterator edgeBasedTarget = _nodeBasedGraph->GetEdgeData(e2).newNodeID; // INFO("edgeBasedSource: " << edgeBasedSource);
if(edgeBasedSource > _nodeBasedGraph->GetNumberOfEdges()) {
ERR("edgeBasedTarget" << edgeBasedSource << ">" << _nodeBasedGraph->GetNumberOfEdges());
}
const _NodeBasedDynamicGraph::NodeIterator edgeBasedTarget = _nodeBasedGraph->GetEdgeData(e2).edgeBasedNodeID;
// INFO("edgeBasedTarget: " << edgeBasedTarget);
if(edgeBasedTarget > _nodeBasedGraph->GetNumberOfEdges()) {
ERR("edgeBasedTarget" << edgeBasedTarget << ">" << _nodeBasedGraph->GetNumberOfEdges());
}
_EdgeBasedEdge newEdge; _EdgeBasedEdge newEdge;
newEdge.source = edgeBasedSource; newEdge.source = edgeBasedSource;
newEdge.target = edgeBasedTarget; newEdge.target = edgeBasedTarget;
@ -146,9 +147,31 @@ void EdgeBasedGraphFactory::Run() {
newEdge.data.distance = _nodeBasedGraph->GetEdgeData(e1).distance; newEdge.data.distance = _nodeBasedGraph->GetEdgeData(e1).distance;
newEdge.data.forward = true; newEdge.data.forward = true;
newEdge.data.backward = false; newEdge.data.backward = false;
newEdge.data.type = 3; newEdge.data.via = v;
newEdge.data.nameID1 = _nodeBasedGraph->GetEdgeData(e1).middleName.nameID;
newEdge.data.nameID2 = _nodeBasedGraph->GetEdgeData(e2).middleName.nameID;
//Todo: turn type angeben
newEdge.data.turnInstruction = 0;
//create Edge for NearestNeighborlookup
edgeBasedEdges.push_back(newEdge); edgeBasedEdges.push_back(newEdge);
EdgeBasedNode currentNode;
if(_nodeBasedGraph->GetEdgeData(e1).type != 14) {
currentNode.lat1 = inputNodeInfoList[u].lat;
currentNode.lon1 = inputNodeInfoList[u].lon;
currentNode.lat2 = inputNodeInfoList[v].lat;
currentNode.lon2 = inputNodeInfoList[v].lon;
currentNode.id = edgeBasedSource;
edgeBasedNodes.push_back(currentNode);
}
if(_nodeBasedGraph->GetEdgeData(e2).type != 14) {
currentNode.lat1 = inputNodeInfoList[v].lat;
currentNode.lon1 = inputNodeInfoList[v].lon;
currentNode.lat2 = inputNodeInfoList[w].lat;
currentNode.lon2 = inputNodeInfoList[w].lon;
currentNode.id = edgeBasedTarget;
edgeBasedNodes.push_back(currentNode);
}
} else { } else {
++numberOfResolvedRestrictions; ++numberOfResolvedRestrictions;
} }
@ -157,9 +180,12 @@ void EdgeBasedGraphFactory::Run() {
} }
p.printIncrement(); p.printIncrement();
} }
std::sort(edgeBasedNodes.begin(), edgeBasedNodes.end());
edgeBasedNodes.erase( std::unique(edgeBasedNodes.begin(), edgeBasedNodes.end()), edgeBasedNodes.end() );
INFO("Node-based graph contains " << nodeBasedEdgeCounter << " edges"); INFO("Node-based graph contains " << nodeBasedEdgeCounter << " edges");
INFO("Edge-based graph contains " << edgeBasedEdges.size() << " edges, blowup is " << (double)edgeBasedEdges.size()/(double)nodeBasedEdgeCounter); INFO("Edge-based graph contains " << edgeBasedEdges.size() << " edges, blowup is " << (double)edgeBasedEdges.size()/(double)nodeBasedEdgeCounter);
INFO("Edge-based graph obeys " << numberOfResolvedRestrictions << " turn restrictions, " << (inputRestrictions.size() - numberOfResolvedRestrictions )<< " skipped."); INFO("Edge-based graph obeys " << numberOfResolvedRestrictions << " turn restrictions, " << (inputRestrictions.size() - numberOfResolvedRestrictions )<< " skipped.");
INFO("Generated " << edgeBasedNodes.size() << " edge based nodes");
} }
unsigned EdgeBasedGraphFactory::GetNumberOfNodes() const { unsigned EdgeBasedGraphFactory::GetNumberOfNodes() const {

41
Contractor/EdgeBasedGraphFactory.h
View File

@ -43,27 +43,43 @@ private:
struct _NodeBasedEdgeData { struct _NodeBasedEdgeData {
unsigned distance; unsigned distance;
unsigned newNodeID; unsigned edgeBasedNodeID;
unsigned originalEdges : 29; unsigned originalEdges;
bool shortcut : 1; bool shortcut;
bool forward : 1; bool forward;
bool backward : 1; bool backward;
short type:6; short type;
_MiddleName middleName; _MiddleName middleName;
} data; } data;
struct _EdgeBasedEdgeData { struct _EdgeBasedEdgeData {
unsigned distance; unsigned distance;
unsigned instruction; unsigned via;
unsigned nameID1;
unsigned nameID2;
bool forward; bool forward;
bool backward; bool backward;
short type; short turnInstruction;
}; };
typedef DynamicGraph< _NodeBasedEdgeData > _NodeBasedDynamicGraph; typedef DynamicGraph< _NodeBasedEdgeData > _NodeBasedDynamicGraph;
typedef _NodeBasedDynamicGraph::InputEdge _NodeBasedEdge; typedef _NodeBasedDynamicGraph::InputEdge _NodeBasedEdge;
public: public:
struct EdgeBasedNode {
bool operator<(const EdgeBasedNode & other) const {
return other.id < id;
}
bool operator==(const EdgeBasedNode & other) const {
return id == other.id;
}
int lat1;
int lat2;
int lon1;
int lon2;
NodeID id;
};
typedef DynamicGraph< _EdgeBasedEdgeData> _EdgeBasedDynamicGraph; typedef DynamicGraph< _EdgeBasedEdgeData> _EdgeBasedDynamicGraph;
typedef _EdgeBasedDynamicGraph::InputEdge _EdgeBasedEdge; typedef _EdgeBasedDynamicGraph::InputEdge _EdgeBasedEdge;
private: private:
@ -71,19 +87,20 @@ private:
boost::shared_ptr<_EdgeBasedDynamicGraph> _edgeBasedGraph; boost::shared_ptr<_EdgeBasedDynamicGraph> _edgeBasedGraph;
std::vector<_Restriction> & inputRestrictions; std::vector<_Restriction> & inputRestrictions;
std::vector<NodeInfo> & inputNodeInfoList;
std::vector<_EdgeBasedEdge> edgeBasedEdges; std::vector<_EdgeBasedEdge> edgeBasedEdges;
std::vector<EdgeBasedNode> edgeBasedNodes;
public: public:
template< class InputEdgeT > template< class InputEdgeT >
explicit EdgeBasedGraphFactory(int nodes, std::vector<InputEdgeT> & inputEdges, std::vector<_Restriction> & inputRestrictions); explicit EdgeBasedGraphFactory(int nodes, std::vector<InputEdgeT> & inputEdges, std::vector<_Restriction> & inputRestrictions, std::vector<NodeInfo> & nI);
virtual ~EdgeBasedGraphFactory(); virtual ~EdgeBasedGraphFactory();
void Run(); void Run();
template< class ImportEdgeT > template< class ImportEdgeT >
void GetEdges( std::vector< ImportEdgeT >& edges ); void GetEdgeBasedEdges( std::vector< ImportEdgeT >& edges );
template< class NodeT > void GetEdgeBasedNodes( std::vector< EdgeBasedNode> & nodes);
void GetNodes( std::vector< NodeT >& edges );
unsigned GetNumberOfNodes() const; unsigned GetNumberOfNodes() const;
}; };