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

Refactored various parts for integration of multi-segment paths

Browse Source
This commit is contained in:
Dennis Luxen
2011-07-11 15:16:14 +00:00
parent 4bbf53ce62
commit f29f6c65a5
12 changed files with 186 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files
DataStructures/ExtractorStructs.h
+3 -1
View File
@@ -77,7 +77,9 @@ struct _Coordinate {
lat = INT_MIN;
lon = INT_MIN;
}
bool isSet() const {
return (INT_MIN != lat) && (INT_MIN != lon);
}
};
ostream & operator<<(ostream & out, const _Coordinate & c){
DataStructures/NNGrid.h
+16 -40
View File
@@ -276,11 +276,9 @@ public:
return false;
}
bool FindRoutingStarts(const _Coordinate& start, const _Coordinate& target, PhantomNodes * routingStarts) {
routingStarts->Reset();
_Coordinate startCoord(100000*(lat2y(static_cast<double>(start.lat)/100000.)), start.lon);
_Coordinate targetCoord(100000*(lat2y(static_cast<double>(target.lat)/100000.)), target.lon);
bool FindPhantomNodeForCoordinate( const _Coordinate & location, PhantomNode & resultNode) {
bool foundNode = false;
_Coordinate startCoord(100000*(lat2y(static_cast<double>(location.lat)/100000.)), location.lon);
/** search for point on edge close to source */
unsigned fileIndex = GetFileIndexForLatLon(startCoord.lat, startCoord.lon);
std::vector<_Edge> candidates;
@@ -292,7 +290,6 @@ public:
}
}
// std::cout << "[debug] " << candidates.size() << " start candidates" << std::endl;
_Coordinate tmp;
double dist = numeric_limits<double>::max();
timestamp = get_timestamp();
@@ -300,44 +297,23 @@ public:
double r = 0.;
double tmpDist = ComputeDistance(startCoord, it->startCoord, it->targetCoord, tmp, &r);
if(tmpDist < dist) {
// std::cout << "[debug] start distance " << (it - candidates.begin()) << " " << tmpDist << std::endl;
routingStarts->startNode1 = it->start;
routingStarts->startNode2 = it->target;
routingStarts->startRatio = r;
// std::cout << "[debug] start distance " << (it - candidates.begin()) << " " << tmpDist << std::endl;
resultNode.startNode = it->start;
resultNode.targetNode = it->target;
resultNode.ratio = r;
dist = tmpDist;
routingStarts->startCoord.lat = round(100000*(y2lat(static_cast<double>(tmp.lat)/100000.)));
routingStarts->startCoord.lon = tmp.lon;
resultNode.location.lat = round(100000*(y2lat(static_cast<double>(tmp.lat)/100000.)));
resultNode.location.lon = tmp.lon;
foundNode = true;
}
}
candidates.clear();
return foundNode;
}
/** search for point on edge close to target */
fileIndex = GetFileIndexForLatLon(targetCoord.lat, targetCoord.lon);
timestamp = get_timestamp();
for(int j = -32768; j < (32768+1); j+=32768) {
for(int i = -1; i < 2; i++){
GetContentsOfFileBucket(fileIndex+i+j, candidates);
}
}
// std::cout << "[debug] " << candidates.size() << " target candidates" << std::endl;
dist = numeric_limits<double>::max();
timestamp = get_timestamp();
for(std::vector<_Edge>::iterator it = candidates.begin(); it != candidates.end(); it++)
{
double r = 0.;
double tmpDist = ComputeDistance(targetCoord, it->startCoord, it->targetCoord, tmp, &r);
if(tmpDist < dist)
{
// std::cout << "[debug] target distance " << (it - candidates.begin()) << " " << tmpDist << std::endl;
routingStarts->targetNode1 = it->start;
routingStarts->targetNode2 = it->target;
routingStarts->targetRatio = r;
dist = tmpDist;
routingStarts->targetCoord.lat = round(100000*(y2lat(static_cast<double>(tmp.lat)/100000.)));
routingStarts->targetCoord.lon = tmp.lon;
}
}
return true;
bool FindRoutingStarts(const _Coordinate& start, const _Coordinate& target, PhantomNodes * routingStarts) {
routingStarts->Reset();
return (FindPhantomNodeForCoordinate( start, routingStarts->startPhantom) &&
FindPhantomNodeForCoordinate( target, routingStarts->targetPhantom) );
}
void FindNearestNodeInGraph(const _Coordinate& inputCoordinate, _Coordinate& outputCoordinate) {
DataStructures/NodeInformationHelpDesk.h
+3
View File
@@ -61,6 +61,9 @@ public:
inline void FindNearestNodeCoordForLatLon(const _Coordinate& coord, _Coordinate& result) {
readOnlyGrid->FindNearestNodeInGraph(coord, result);
}
bool FindPhantomNodeForCoordinate( const _Coordinate & location, PhantomNode & resultNode) {
return readOnlyGrid->FindPhantomNodeForCoordinate(location, resultNode);
}
inline bool FindRoutingStarts(const _Coordinate &start, const _Coordinate &target, PhantomNodes * phantomNodes) {
readOnlyGrid->FindRoutingStarts(start, target, phantomNodes);
DataStructures/PhantomNodes.h
+27 -24
View File
@@ -23,35 +23,38 @@ or see http://www.gnu.org/licenses/agpl.txt.
#include "ExtractorStructs.h"
struct PhantomNodes {
PhantomNodes() : startNode1(UINT_MAX), startNode2(UINT_MAX), targetNode1(UINT_MAX), targetNode2(UINT_MAX), startRatio(1.), targetRatio(1.) {}
NodeID startNode1;
NodeID startNode2;
NodeID targetNode1;
NodeID targetNode2;
double startRatio;
double targetRatio;
_Coordinate startCoord;
_Coordinate targetCoord;
struct PhantomNode {
PhantomNode() : startNode(UINT_MAX), targetNode(UINT_MAX), ratio(1.) {}
NodeID startNode;
NodeID targetNode;
double ratio;
_Coordinate location;
void Reset() {
startNode1 = UINT_MAX;
startNode2 = UINT_MAX;
targetNode1 = UINT_MAX;
targetNode2 = UINT_MAX;
startRatio = 1.;
targetRatio = 1.;
startCoord.Reset();
targetCoord.Reset();
startNode = UINT_MAX;
targetNode = UINT_MAX;
ratio = 1.;
location.Reset();
}
};
struct PhantomNodes {
PhantomNode startPhantom;
PhantomNode targetPhantom;
void Reset() {
startPhantom.Reset();
targetPhantom.Reset();
}
};
std::ostream& operator<<(std::ostream &out, const PhantomNodes & pn){
out << "startNode1: " << pn.startNode1 << std::endl;
out << "startNode2: " << pn.startNode2 << std::endl;
out << "targetNode1: " << pn.targetNode1 << std::endl;
out << "targetNode2: " << pn.targetNode2 << std::endl;
out << "startCoord: " << pn.startCoord << std::endl;
out << "targetCoord: " << pn.targetCoord << std::endl;
out << "startNode1: " << pn.startPhantom.startNode << std::endl;
out << "startNode2: " << pn.startPhantom.targetNode << std::endl;
out << "targetNode1: " << pn.targetPhantom.startNode << std::endl;
out << "targetNode2: " << pn.targetPhantom.targetNode << std::endl;
out << "startCoord: " << pn.startPhantom.location << std::endl;
out << "targetCoord: " << pn.targetPhantom.location << std::endl;
return out;
}
DataStructures/SearchEngine.h
+42 -34
View File
@@ -108,7 +108,6 @@ public:
}
unsigned int ComputeRoute(PhantomNodes * phantomNodes, vector<_PathData > * path) {
bool onSameEdge = false;
bool onSameEdgeReversed = false;
bool startReverse = false;
@@ -121,16 +120,16 @@ public:
NodeID middle = ( NodeID ) 0;
unsigned int _upperbound = std::numeric_limits<unsigned int>::max();
if(phantomNodes->startNode1 == UINT_MAX || phantomNodes->targetNode1 == UINT_MAX || phantomNodes->startNode2 == UINT_MAX || phantomNodes->targetNode2 == UINT_MAX)
if(phantomNodes->startPhantom.startNode == UINT_MAX || phantomNodes->startPhantom.targetNode == UINT_MAX || phantomNodes->targetPhantom.startNode == UINT_MAX || phantomNodes->targetPhantom.targetNode == UINT_MAX)
return _upperbound;
if( (phantomNodes->startNode1 == phantomNodes->targetNode1 && phantomNodes->startNode2 == phantomNodes->targetNode2 ) ||
(phantomNodes->startNode1 == phantomNodes->targetNode2 && phantomNodes->startNode2 == phantomNodes->targetNode1 ) )
if( (phantomNodes->startPhantom.startNode == phantomNodes->startPhantom.targetNode && phantomNodes->targetPhantom.startNode == phantomNodes->targetPhantom.targetNode ) ||
(phantomNodes->startPhantom.startNode == phantomNodes->targetPhantom.targetNode && phantomNodes->targetPhantom.startNode == phantomNodes->startPhantom.targetNode) )
{
bool reverse = false;
EdgeID currentEdge = _graph->FindEdge( phantomNodes->startNode1, phantomNodes->startNode2 );
EdgeID currentEdge = _graph->FindEdge( phantomNodes->startPhantom.startNode, phantomNodes->startPhantom.targetNode );
if(currentEdge == UINT_MAX){
currentEdge = _graph->FindEdge( phantomNodes->startNode2, phantomNodes->startNode1 );
currentEdge = _graph->FindEdge( phantomNodes->startPhantom.targetNode, phantomNodes->startPhantom.startNode );
reverse = true;
}
@@ -138,34 +137,34 @@ public:
return _upperbound;
}
if(phantomNodes->startRatio < phantomNodes->targetRatio && _graph->GetEdgeData(currentEdge).forward) {
if(phantomNodes->startPhantom.ratio < phantomNodes->targetPhantom.ratio && _graph->GetEdgeData(currentEdge).forward) {
onSameEdge = true;
_upperbound = 10 * ApproximateDistance(phantomNodes->startCoord.lat, phantomNodes->startCoord.lon, phantomNodes->targetCoord.lat, phantomNodes->targetCoord.lon);
} else if(phantomNodes->startRatio > phantomNodes->targetRatio && _graph->GetEdgeData(currentEdge).backward && !reverse)
_upperbound = 10 * ApproximateDistance(phantomNodes->startPhantom.location.lat, phantomNodes->startPhantom.location.lon, phantomNodes->targetPhantom.location.lat, phantomNodes->targetPhantom.location.lon);
} else if(phantomNodes->startPhantom.ratio > phantomNodes->targetPhantom.ratio && _graph->GetEdgeData(currentEdge).backward && !reverse)
{
onSameEdge = true;
_upperbound = 10 * ApproximateDistance(phantomNodes->startCoord.lat, phantomNodes->startCoord.lon, phantomNodes->targetCoord.lat, phantomNodes->targetCoord.lon);
} else if(phantomNodes->startRatio < phantomNodes->targetRatio && _graph->GetEdgeData(currentEdge).backward) {
_upperbound = 10 * ApproximateDistance(phantomNodes->startPhantom.location.lat, phantomNodes->startPhantom.location.lon, phantomNodes->targetPhantom.location.lat, phantomNodes->targetPhantom.location.lon);
} else if(phantomNodes->startPhantom.ratio < phantomNodes->targetPhantom.ratio && _graph->GetEdgeData(currentEdge).backward) {
onSameEdge = true;
_upperbound = 10 * ApproximateDistance(phantomNodes->startCoord.lat, phantomNodes->startCoord.lon, phantomNodes->targetCoord.lat, phantomNodes->targetCoord.lon);
} else if(phantomNodes->startRatio > phantomNodes->targetRatio && _graph->GetEdgeData(currentEdge).forward && _graph->GetEdgeData(currentEdge).backward) {
_upperbound = 10 * ApproximateDistance(phantomNodes->startPhantom.location.lat, phantomNodes->startPhantom.location.lon, phantomNodes->targetPhantom.location.lat, phantomNodes->targetPhantom.location.lon);
} else if(phantomNodes->startPhantom.ratio > phantomNodes->targetPhantom.ratio && _graph->GetEdgeData(currentEdge).forward && _graph->GetEdgeData(currentEdge).backward) {
onSameEdge = true;
_upperbound = 10 * ApproximateDistance(phantomNodes->startCoord.lat, phantomNodes->startCoord.lon, phantomNodes->targetCoord.lat, phantomNodes->targetCoord.lon);
} else if(phantomNodes->startRatio > phantomNodes->targetRatio) {
_upperbound = 10 * ApproximateDistance(phantomNodes->startPhantom.location.lat, phantomNodes->startPhantom.location.lon, phantomNodes->targetPhantom.location.lat, phantomNodes->targetPhantom.location.lon);
} else if(phantomNodes->startPhantom.ratio > phantomNodes->targetPhantom.ratio) {
onSameEdgeReversed = true;
EdgeWeight w = _graph->GetEdgeData( currentEdge ).distance;
_forwardHeap.Insert(phantomNodes->startNode2, absDouble( w*phantomNodes->startRatio), phantomNodes->startNode2);
_insertedNodes.ForwInsert(phantomNodes->startNode2);
_backwardHeap.Insert(phantomNodes->startNode1, absDouble( w-w*phantomNodes->targetRatio), phantomNodes->startNode1);
_insertedNodes.BackInsert(phantomNodes->startNode1);
_forwardHeap.Insert(phantomNodes->targetPhantom.startNode, absDouble( w*phantomNodes->startPhantom.ratio), phantomNodes->targetPhantom.startNode);
_insertedNodes.ForwInsert(phantomNodes->targetPhantom.startNode);
_backwardHeap.Insert(phantomNodes->startPhantom.startNode, absDouble( w-w*phantomNodes->targetPhantom.ratio), phantomNodes->startPhantom.startNode);
_insertedNodes.BackInsert(phantomNodes->startPhantom.startNode);
}
}
if(phantomNodes->startNode1 != UINT_MAX) {
EdgeID edge = _graph->FindEdge( phantomNodes->startNode1, phantomNodes->startNode2);
if(phantomNodes->startPhantom.startNode != UINT_MAX) {
EdgeID edge = _graph->FindEdge( phantomNodes->startPhantom.startNode, phantomNodes->startPhantom.targetNode);
if(edge == UINT_MAX){
edge = _graph->FindEdge( phantomNodes->startNode2, phantomNodes->startNode1 );
edge = _graph->FindEdge( phantomNodes->startPhantom.targetNode, phantomNodes->startPhantom.startNode );
if(edge == UINT_MAX){
return _upperbound;
}
@@ -175,18 +174,18 @@ public:
EdgeWeight w = ed.distance;
if( (ed.backward && !startReverse) || (ed.forward && startReverse) ){
_forwardHeap.Insert(phantomNodes->startNode1, absDouble( w*phantomNodes->startRatio), phantomNodes->startNode1);
_insertedNodes.ForwInsert(phantomNodes->startNode1);
_forwardHeap.Insert(phantomNodes->startPhantom.startNode, absDouble( w*phantomNodes->startPhantom.ratio), phantomNodes->startPhantom.startNode);
_insertedNodes.ForwInsert(phantomNodes->startPhantom.startNode);
}
if( (ed.backward && startReverse) || (ed.forward && !startReverse) ) {
_forwardHeap.Insert(phantomNodes->startNode2, absDouble(w-w*phantomNodes->startRatio), phantomNodes->startNode2);
_insertedNodes.ForwInsert(phantomNodes->startNode2);
_forwardHeap.Insert(phantomNodes->startPhantom.targetNode, absDouble(w-w*phantomNodes->startPhantom.ratio), phantomNodes->startPhantom.targetNode);
_insertedNodes.ForwInsert(phantomNodes->startPhantom.targetNode);
}
}
if(phantomNodes->targetNode1 != UINT_MAX && !onSameEdgeReversed) {
EdgeID edge = _graph->FindEdge( phantomNodes->targetNode1, phantomNodes->targetNode2);
if(phantomNodes->startPhantom.targetNode!= UINT_MAX && !onSameEdgeReversed) {
EdgeID edge = _graph->FindEdge( phantomNodes->targetPhantom.startNode, phantomNodes->targetPhantom.targetNode);
if(edge == UINT_MAX){
edge = _graph->FindEdge( phantomNodes->targetNode2, phantomNodes->targetNode1 );
edge = _graph->FindEdge( phantomNodes->targetPhantom.targetNode, phantomNodes->targetPhantom.startNode);
targetReverse = true;
}
if(edge == UINT_MAX){
@@ -197,12 +196,12 @@ public:
EdgeWeight w = ed.distance;
if( (ed.backward && !targetReverse) || (ed.forward && targetReverse) ) {
_backwardHeap.Insert(phantomNodes->targetNode2, absDouble( w*phantomNodes->targetRatio), phantomNodes->targetNode2);
_insertedNodes.BackInsert(phantomNodes->targetNode2);
_backwardHeap.Insert(phantomNodes->targetPhantom.targetNode, absDouble( w*phantomNodes->targetPhantom.ratio), phantomNodes->targetPhantom.targetNode);
_insertedNodes.BackInsert(phantomNodes->targetPhantom.targetNode);
}
if( (ed.backward && targetReverse) || (ed.forward && !targetReverse) ) {
_backwardHeap.Insert(phantomNodes->targetNode1, absDouble(w-w*phantomNodes->targetRatio), phantomNodes->targetNode1);
_insertedNodes.BackInsert(phantomNodes->targetNode1);
_backwardHeap.Insert(phantomNodes->targetPhantom.startNode, absDouble(w-w*phantomNodes->targetPhantom.ratio), phantomNodes->targetPhantom.startNode);
_insertedNodes.BackInsert(phantomNodes->targetPhantom.startNode);
}
}
// double time = get_timestamp();
@@ -308,11 +307,20 @@ public:
return true;
}
inline bool FindPhantomNodeForCoordinate(const _Coordinate &location, PhantomNode & result) {
return nodeHelpDesk->FindPhantomNodeForCoordinate(location, result);
}
inline NodeID GetNameIDForOriginDestinationNodeID(NodeID s, NodeID t) const {
assert(s!=t);
if(s==t)
return 0;
EdgeID e = _graph->FindEdge( s, t );
if(e == UINT_MAX)
e = _graph->FindEdge( t, s );
if(UINT_MAX == e) {
INFO("edge not found for start " << s << ", target " << t)
return 0;
}
assert(e != UINT_MAX);
const EdgeData ed = _graph->GetEdgeData(e);
return ed.middleName.nameID;