performance fixes
This commit is contained in:
Dennis Luxen
parent
a5c94c4630
commit
bcb39b9e69
@ -32,7 +32,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
|
||||
#include <google/sparse_hash_map>
|
||||
#include <google/sparsetable>
|
||||
|
||||
template< typename NodeID, typename Key, bool initialize = true >
|
||||
template< typename NodeID, typename Key, bool initialize = false >
|
||||
class ArrayStorage {
|
||||
public:
|
||||
|
||||
|
||||
@ -30,58 +30,58 @@ or see http://www.gnu.org/licenses/agpl.txt.
|
||||
#include "../typedefs.h"
|
||||
|
||||
struct _HeapData {
|
||||
NodeID parent;
|
||||
_HeapData( NodeID p ) : parent(p) { }
|
||||
NodeID parent;
|
||||
_HeapData( NodeID p ) : parent(p) { }
|
||||
};
|
||||
|
||||
struct _Statistics {
|
||||
_Statistics () : insertedNodes(0), stalledNodes(0), meetingNodes(0), deleteMins(0), decreasedNodes(0), oqf(0), eqf(0), df(0), preprocTime(0) {};
|
||||
void Reset() {
|
||||
insertedNodes = 0;
|
||||
stalledNodes = 0;
|
||||
meetingNodes = 0;
|
||||
deleteMins = 0;
|
||||
decreasedNodes = 0;
|
||||
}
|
||||
unsigned insertedNodes;
|
||||
unsigned stalledNodes;
|
||||
unsigned meetingNodes;
|
||||
unsigned deleteMins;
|
||||
unsigned decreasedNodes;
|
||||
unsigned oqf;
|
||||
unsigned eqf;
|
||||
unsigned df;
|
||||
double preprocTime;
|
||||
_Statistics () : insertedNodes(0), stalledNodes(0), meetingNodes(0), deleteMins(0), decreasedNodes(0), oqf(0), eqf(0), df(0), preprocTime(0) {};
|
||||
void Reset() {
|
||||
insertedNodes = 0;
|
||||
stalledNodes = 0;
|
||||
meetingNodes = 0;
|
||||
deleteMins = 0;
|
||||
decreasedNodes = 0;
|
||||
}
|
||||
unsigned insertedNodes;
|
||||
unsigned stalledNodes;
|
||||
unsigned meetingNodes;
|
||||
unsigned deleteMins;
|
||||
unsigned decreasedNodes;
|
||||
unsigned oqf;
|
||||
unsigned eqf;
|
||||
unsigned df;
|
||||
double preprocTime;
|
||||
};
|
||||
|
||||
struct _InsertedNodes {
|
||||
NodeID forward1;
|
||||
NodeID forward2;
|
||||
NodeID backward1;
|
||||
NodeID backward2;
|
||||
_InsertedNodes() : forward1(UINT_MAX), forward2(UINT_MAX), backward1(UINT_MAX), backward2(UINT_MAX) {};
|
||||
void BackInsert(NodeID n) {
|
||||
if(backward1 == UINT_MAX) {
|
||||
backward1 = n;
|
||||
} else {
|
||||
backward2 = n;
|
||||
}
|
||||
}
|
||||
void ForwInsert( NodeID n) {
|
||||
if(forward1 == UINT_MAX) {
|
||||
forward1 = n;
|
||||
} else {
|
||||
forward2 = n;
|
||||
}
|
||||
}
|
||||
NodeID forward1;
|
||||
NodeID forward2;
|
||||
NodeID backward1;
|
||||
NodeID backward2;
|
||||
_InsertedNodes() : forward1(UINT_MAX), forward2(UINT_MAX), backward1(UINT_MAX), backward2(UINT_MAX) {};
|
||||
void BackInsert(NodeID n) {
|
||||
if(backward1 == UINT_MAX) {
|
||||
backward1 = n;
|
||||
} else {
|
||||
backward2 = n;
|
||||
}
|
||||
}
|
||||
void ForwInsert( NodeID n) {
|
||||
if(forward1 == UINT_MAX) {
|
||||
forward1 = n;
|
||||
} else {
|
||||
forward2 = n;
|
||||
}
|
||||
}
|
||||
|
||||
inline bool isForwardInserted(NodeID n) {
|
||||
return forward1 == n || forward2 == n;
|
||||
}
|
||||
inline bool isForwardInserted(NodeID n) {
|
||||
return forward1 == n || forward2 == n;
|
||||
}
|
||||
|
||||
inline bool isBackwardInserted (NodeID n) {
|
||||
return backward1 == n || backward2 == n;
|
||||
}
|
||||
inline bool isBackwardInserted (NodeID n) {
|
||||
return backward1 == n || backward2 == n;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@ -90,390 +90,391 @@ typedef BinaryHeap< NodeID, int, int, _HeapData, ArrayStorage<NodeID, NodeID> >
|
||||
template<typename EdgeData, typename GraphT, typename NodeHelperT = NodeInformationHelpDesk>
|
||||
class SearchEngine {
|
||||
private:
|
||||
const GraphT * _graph;
|
||||
NodeHelperT * nodeHelpDesk;
|
||||
std::vector<string> * _names;
|
||||
inline double absDouble(double input) { if(input < 0) return input*(-1); else return input;}
|
||||
const GraphT * _graph;
|
||||
NodeHelperT * nodeHelpDesk;
|
||||
std::vector<string> * _names;
|
||||
inline double absDouble(double input) { if(input < 0) return input*(-1); else return input;}
|
||||
public:
|
||||
SearchEngine(GraphT * g, NodeHelperT * nh, vector<string> * n = new vector<string>()) : _graph(g), nodeHelpDesk(nh), _names(n) {}
|
||||
~SearchEngine() {}
|
||||
SearchEngine(GraphT * g, NodeHelperT * nh, vector<string> * n = new vector<string>()) : _graph(g), nodeHelpDesk(nh), _names(n) {}
|
||||
~SearchEngine() {}
|
||||
|
||||
inline const void getCoordinatesForNodeID(NodeID id, _Coordinate& result) const {
|
||||
result.lat = nodeHelpDesk->getLatitudeOfNode(id);
|
||||
result.lon = nodeHelpDesk->getLongitudeOfNode(id);
|
||||
}
|
||||
inline const void getCoordinatesForNodeID(NodeID id, _Coordinate& result) const {
|
||||
result.lat = nodeHelpDesk->getLatitudeOfNode(id);
|
||||
result.lon = nodeHelpDesk->getLongitudeOfNode(id);
|
||||
}
|
||||
|
||||
unsigned int numberOfNodes() const {
|
||||
return nodeHelpDesk->getNumberOfNodes();
|
||||
}
|
||||
unsigned int numberOfNodes() const {
|
||||
return nodeHelpDesk->getNumberOfNodes();
|
||||
}
|
||||
|
||||
unsigned int ComputeRoute(PhantomNodes &phantomNodes, vector<_PathData > & path) {
|
||||
bool startEdgeIsReversedInGraph = false;
|
||||
bool targetEdgeIsReversed = false;
|
||||
unsigned int ComputeRoute(PhantomNodes &phantomNodes, vector<_PathData > & path) {
|
||||
|
||||
unsigned int _upperbound = UINT_MAX;
|
||||
bool startEdgeIsReversedInGraph = false;
|
||||
bool targetEdgeIsReversed = false;
|
||||
|
||||
if(!phantomNodes.AtLeastOnePhantomNodeIsUINTMAX())
|
||||
return _upperbound;
|
||||
unsigned int _upperbound = UINT_MAX;
|
||||
|
||||
EdgeID sourceEdgeID = _graph->FindEdgeIndicateIfReverse( phantomNodes.startPhantom.startNode, phantomNodes.startPhantom.targetNode, startEdgeIsReversedInGraph);
|
||||
if(sourceEdgeID == UINT_MAX){
|
||||
return _upperbound;
|
||||
}
|
||||
if(!phantomNodes.AtLeastOnePhantomNodeIsUINTMAX())
|
||||
return _upperbound;
|
||||
|
||||
EdgeID targetEdgeID = _graph->FindEdgeIndicateIfReverse( phantomNodes.targetPhantom.startNode, phantomNodes.targetPhantom.targetNode, targetEdgeIsReversed);
|
||||
if(targetEdgeID == UINT_MAX){
|
||||
return _upperbound;
|
||||
}
|
||||
EdgeID sourceEdgeID = _graph->FindEdgeIndicateIfReverse( phantomNodes.startPhantom.startNode, phantomNodes.startPhantom.targetNode, startEdgeIsReversedInGraph);
|
||||
if(sourceEdgeID == UINT_MAX){
|
||||
return _upperbound;
|
||||
}
|
||||
|
||||
_InsertedNodes _insertedNodes;
|
||||
_Heap _forwardHeap(nodeHelpDesk->getNumberOfNodes());
|
||||
_Heap _backwardHeap(nodeHelpDesk->getNumberOfNodes());
|
||||
EdgeID targetEdgeID = _graph->FindEdgeIndicateIfReverse( phantomNodes.targetPhantom.startNode, phantomNodes.targetPhantom.targetNode, targetEdgeIsReversed);
|
||||
if(targetEdgeID == UINT_MAX){
|
||||
return _upperbound;
|
||||
}
|
||||
|
||||
NodeID middle = ( NodeID ) 0;
|
||||
_InsertedNodes _insertedNodes;
|
||||
|
||||
if( phantomNodes.PhantomsAreOnSameEdge() ) {
|
||||
const EdgeData& currentEdgeData = _graph->GetEdgeData(sourceEdgeID);
|
||||
EdgeWeight w = currentEdgeData.distance;
|
||||
_Heap _forwardHeap(nodeHelpDesk->getNumberOfNodes());
|
||||
_Heap _backwardHeap(nodeHelpDesk->getNumberOfNodes());
|
||||
|
||||
//check if target is reachable from start on same edge
|
||||
if(currentEdgeData.forward && currentEdgeData.backward) {
|
||||
_upperbound = absDouble( w*phantomNodes.targetPhantom.ratio);
|
||||
return _upperbound/10;
|
||||
} else {
|
||||
if((startEdgeIsReversedInGraph && (phantomNodes.startPhantom.ratio > phantomNodes.targetPhantom.ratio)) || (!startEdgeIsReversedInGraph && (phantomNodes.startPhantom.ratio < phantomNodes.targetPhantom.ratio))) {
|
||||
_backwardHeap.Insert(phantomNodes.startPhantom.startNode, absDouble( w*phantomNodes.startPhantom.ratio), phantomNodes.startPhantom.startNode);
|
||||
_insertedNodes.BackInsert(phantomNodes.startPhantom.startNode);
|
||||
_forwardHeap.Insert(phantomNodes.startPhantom.targetNode, absDouble( w-w*phantomNodes.startPhantom.ratio), phantomNodes.startPhantom.targetNode);
|
||||
_insertedNodes.ForwInsert(phantomNodes.startPhantom.targetNode);
|
||||
} else {
|
||||
_upperbound = absDouble( w*phantomNodes.targetPhantom.ratio);
|
||||
return _upperbound/10;
|
||||
}
|
||||
}
|
||||
}
|
||||
NodeID middle = ( NodeID ) UINT_MAX;
|
||||
|
||||
//insert start and/or target node of start edge
|
||||
const EdgeData& sourceEdgeData = _graph->GetEdgeData(sourceEdgeID);
|
||||
EdgeWeight sw = sourceEdgeData.distance;
|
||||
if( phantomNodes.PhantomsAreOnSameEdge() ) {
|
||||
const EdgeData& currentEdgeData = _graph->GetEdgeData(sourceEdgeID);
|
||||
EdgeWeight w = currentEdgeData.distance;
|
||||
|
||||
if( (sourceEdgeData.backward && !startEdgeIsReversedInGraph) || (sourceEdgeData.forward && startEdgeIsReversedInGraph) ){
|
||||
_forwardHeap.Insert(phantomNodes.startPhantom.startNode, absDouble( sw*phantomNodes.startPhantom.ratio), phantomNodes.startPhantom.startNode);
|
||||
_insertedNodes.ForwInsert(phantomNodes.startPhantom.startNode);
|
||||
}
|
||||
if( (sourceEdgeData.backward && startEdgeIsReversedInGraph) || (sourceEdgeData.forward && !startEdgeIsReversedInGraph) ) {
|
||||
_forwardHeap.Insert(phantomNodes.startPhantom.targetNode, absDouble(sw-sw*phantomNodes.startPhantom.ratio), phantomNodes.startPhantom.targetNode);
|
||||
_insertedNodes.ForwInsert(phantomNodes.startPhantom.targetNode);
|
||||
}
|
||||
//check if target is reachable from start on same edge
|
||||
if(currentEdgeData.forward && currentEdgeData.backward) {
|
||||
_upperbound = absDouble( w*phantomNodes.targetPhantom.ratio);
|
||||
return _upperbound/10;
|
||||
} else {
|
||||
if((startEdgeIsReversedInGraph && (phantomNodes.startPhantom.ratio > phantomNodes.targetPhantom.ratio)) || (!startEdgeIsReversedInGraph && (phantomNodes.startPhantom.ratio < phantomNodes.targetPhantom.ratio))) {
|
||||
_backwardHeap.Insert(phantomNodes.startPhantom.startNode, absDouble( w*phantomNodes.startPhantom.ratio), phantomNodes.startPhantom.startNode);
|
||||
_insertedNodes.BackInsert(phantomNodes.startPhantom.startNode);
|
||||
_forwardHeap.Insert(phantomNodes.startPhantom.targetNode, absDouble( w-w*phantomNodes.startPhantom.ratio), phantomNodes.startPhantom.targetNode);
|
||||
_insertedNodes.ForwInsert(phantomNodes.startPhantom.targetNode);
|
||||
} else {
|
||||
_upperbound = absDouble( w*phantomNodes.targetPhantom.ratio);
|
||||
return _upperbound/10;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//insert start and/or target node of target edge id
|
||||
const EdgeData& targetEdgeData = _graph->GetEdgeData(targetEdgeID);
|
||||
EdgeWeight tw = targetEdgeData.distance;
|
||||
//insert start and/or target node of start edge
|
||||
const EdgeData& sourceEdgeData = _graph->GetEdgeData(sourceEdgeID);
|
||||
EdgeWeight sw = sourceEdgeData.distance;
|
||||
|
||||
if( (targetEdgeData.backward && !targetEdgeIsReversed) || (targetEdgeData.forward && targetEdgeIsReversed) ) {
|
||||
_backwardHeap.Insert(phantomNodes.targetPhantom.targetNode, absDouble( tw*phantomNodes.targetPhantom.ratio), phantomNodes.targetPhantom.targetNode);
|
||||
_insertedNodes.BackInsert(phantomNodes.targetPhantom.targetNode);
|
||||
}
|
||||
if( (targetEdgeData.backward && targetEdgeIsReversed) || (targetEdgeData.forward && !targetEdgeIsReversed) ) {
|
||||
_backwardHeap.Insert(phantomNodes.targetPhantom.startNode, absDouble(tw-tw*phantomNodes.targetPhantom.ratio), phantomNodes.targetPhantom.startNode);
|
||||
_insertedNodes.BackInsert(phantomNodes.targetPhantom.startNode);
|
||||
}
|
||||
if( (sourceEdgeData.backward && !startEdgeIsReversedInGraph) || (sourceEdgeData.forward && startEdgeIsReversedInGraph) ){
|
||||
_forwardHeap.Insert(phantomNodes.startPhantom.startNode, absDouble( sw*phantomNodes.startPhantom.ratio), phantomNodes.startPhantom.startNode);
|
||||
_insertedNodes.ForwInsert(phantomNodes.startPhantom.startNode);
|
||||
}
|
||||
if( (sourceEdgeData.backward && startEdgeIsReversedInGraph) || (sourceEdgeData.forward && !startEdgeIsReversedInGraph) ) {
|
||||
_forwardHeap.Insert(phantomNodes.startPhantom.targetNode, absDouble(sw-sw*phantomNodes.startPhantom.ratio), phantomNodes.startPhantom.targetNode);
|
||||
_insertedNodes.ForwInsert(phantomNodes.startPhantom.targetNode);
|
||||
}
|
||||
|
||||
//insert start and/or target node of target edge id
|
||||
const EdgeData& targetEdgeData = _graph->GetEdgeData(targetEdgeID);
|
||||
EdgeWeight tw = targetEdgeData.distance;
|
||||
|
||||
while(_forwardHeap.Size() + _backwardHeap.Size() > 0) {
|
||||
if ( _forwardHeap.Size() > 0 ) {
|
||||
_RoutingStep( _forwardHeap, _backwardHeap, true, &middle, &_upperbound );
|
||||
}
|
||||
if ( _backwardHeap.Size() > 0 ) {
|
||||
_RoutingStep( _backwardHeap, _forwardHeap, false, &middle, &_upperbound );
|
||||
}
|
||||
}
|
||||
if( (targetEdgeData.backward && !targetEdgeIsReversed) || (targetEdgeData.forward && targetEdgeIsReversed) ) {
|
||||
_backwardHeap.Insert(phantomNodes.targetPhantom.targetNode, absDouble( tw*phantomNodes.targetPhantom.ratio), phantomNodes.targetPhantom.targetNode);
|
||||
_insertedNodes.BackInsert(phantomNodes.targetPhantom.targetNode);
|
||||
}
|
||||
if( (targetEdgeData.backward && targetEdgeIsReversed) || (targetEdgeData.forward && !targetEdgeIsReversed) ) {
|
||||
_backwardHeap.Insert(phantomNodes.targetPhantom.startNode, absDouble(tw-tw*phantomNodes.targetPhantom.ratio), phantomNodes.targetPhantom.startNode);
|
||||
_insertedNodes.BackInsert(phantomNodes.targetPhantom.startNode);
|
||||
}
|
||||
|
||||
if ( _upperbound == UINT_MAX ) {
|
||||
return _upperbound;
|
||||
}
|
||||
while(_forwardHeap.Size() + _backwardHeap.Size() > 0) {
|
||||
if ( _forwardHeap.Size() > 0 ) {
|
||||
_RoutingStep( _forwardHeap, _backwardHeap, true, &middle, &_upperbound );
|
||||
}
|
||||
if ( _backwardHeap.Size() > 0 ) {
|
||||
_RoutingStep( _backwardHeap, _forwardHeap, false, &middle, &_upperbound );
|
||||
}
|
||||
}
|
||||
|
||||
NodeID pathNode = middle;
|
||||
deque< NodeID > packedPath;
|
||||
if ( _upperbound == UINT_MAX ) {
|
||||
return _upperbound;
|
||||
}
|
||||
|
||||
while ( false == _insertedNodes.isForwardInserted(pathNode) ) {
|
||||
pathNode = _forwardHeap.GetData( pathNode ).parent;
|
||||
packedPath.push_front( pathNode );
|
||||
}
|
||||
NodeID pathNode = middle;
|
||||
deque< NodeID > packedPath;
|
||||
|
||||
packedPath.push_back( middle );
|
||||
pathNode = middle;
|
||||
while ( false == _insertedNodes.isForwardInserted(pathNode) ) {
|
||||
pathNode = _forwardHeap.GetData( pathNode ).parent;
|
||||
packedPath.push_front( pathNode );
|
||||
}
|
||||
|
||||
while ( false == _insertedNodes.isBackwardInserted(pathNode) ){
|
||||
pathNode = _backwardHeap.GetData( pathNode ).parent;
|
||||
packedPath.push_back( pathNode );
|
||||
}
|
||||
packedPath.push_back( middle );
|
||||
pathNode = middle;
|
||||
|
||||
path.push_back( _PathData(packedPath[0]) );
|
||||
for(deque<NodeID>::size_type i = 0; i < packedPath.size()-1; i++) {
|
||||
_UnpackEdge(packedPath[i], packedPath[i+1], path);
|
||||
}
|
||||
while ( false == _insertedNodes.isBackwardInserted(pathNode) ){
|
||||
pathNode = _backwardHeap.GetData( pathNode ).parent;
|
||||
packedPath.push_back( pathNode );
|
||||
}
|
||||
|
||||
packedPath.clear();
|
||||
return _upperbound/10;
|
||||
}
|
||||
path.push_back( _PathData(packedPath[0]) );
|
||||
for(deque<NodeID>::size_type i = 0; i < packedPath.size()-1; i++) {
|
||||
_UnpackEdge(packedPath[i], packedPath[i+1], path);
|
||||
}
|
||||
|
||||
unsigned int ComputeDistanceBetweenNodes(NodeID start, NodeID target) {
|
||||
_Heap _forwardHeap(_graph->GetNumberOfNodes());
|
||||
_Heap _backwardHeap(_graph->GetNumberOfNodes());
|
||||
NodeID middle(UINT_MAX);
|
||||
unsigned int _upperbound = UINT_MAX;
|
||||
packedPath.clear();
|
||||
return _upperbound/10;
|
||||
}
|
||||
|
||||
_forwardHeap.Insert(start, 0, start);
|
||||
_backwardHeap.Insert(target, 0, target);
|
||||
unsigned int ComputeDistanceBetweenNodes(NodeID start, NodeID target) {
|
||||
_Heap _forwardHeap(_graph->GetNumberOfNodes());
|
||||
_Heap _backwardHeap(_graph->GetNumberOfNodes());
|
||||
NodeID middle(UINT_MAX);
|
||||
unsigned int _upperbound = UINT_MAX;
|
||||
|
||||
while(_forwardHeap.Size() + _backwardHeap.Size() > 0) {
|
||||
if ( _forwardHeap.Size() > 0 ) {
|
||||
_RoutingStep( _forwardHeap, _backwardHeap, true, &middle, &_upperbound );
|
||||
}
|
||||
if ( _backwardHeap.Size() > 0 ) {
|
||||
_RoutingStep( _backwardHeap, _forwardHeap, false, &middle, &_upperbound );
|
||||
}
|
||||
}
|
||||
return _upperbound;
|
||||
}
|
||||
_forwardHeap.Insert(start, 0, start);
|
||||
_backwardHeap.Insert(target, 0, target);
|
||||
|
||||
unsigned int ComputeDistanceBetweenNodesWithStats(NodeID start, NodeID target, _Statistics& stats) {
|
||||
_Heap _forwardHeap(_graph->GetNumberOfNodes());
|
||||
_Heap _backwardHeap(_graph->GetNumberOfNodes());
|
||||
NodeID middle(UINT_MAX);
|
||||
unsigned int _upperbound = UINT_MAX;
|
||||
while(_forwardHeap.Size() + _backwardHeap.Size() > 0) {
|
||||
if ( _forwardHeap.Size() > 0 ) {
|
||||
_RoutingStep( _forwardHeap, _backwardHeap, true, &middle, &_upperbound );
|
||||
}
|
||||
if ( _backwardHeap.Size() > 0 ) {
|
||||
_RoutingStep( _backwardHeap, _forwardHeap, false, &middle, &_upperbound );
|
||||
}
|
||||
}
|
||||
return _upperbound;
|
||||
}
|
||||
|
||||
_forwardHeap.Insert(start, 0, start);
|
||||
_backwardHeap.Insert(target, 0, target);
|
||||
stats.insertedNodes += 2;
|
||||
unsigned int ComputeDistanceBetweenNodesWithStats(NodeID start, NodeID target, _Statistics& stats) {
|
||||
_Heap _forwardHeap(_graph->GetNumberOfNodes());
|
||||
_Heap _backwardHeap(_graph->GetNumberOfNodes());
|
||||
NodeID middle(UINT_MAX);
|
||||
unsigned int _upperbound = UINT_MAX;
|
||||
|
||||
while(_forwardHeap.Size() + _backwardHeap.Size() > 0) {
|
||||
if ( _forwardHeap.Size() > 0 ) {
|
||||
_RoutingStepWithStats( _forwardHeap, _backwardHeap, true, &middle, &_upperbound, stats );
|
||||
}
|
||||
if ( _backwardHeap.Size() > 0 ) {
|
||||
_RoutingStepWithStats( _backwardHeap, _forwardHeap, false, &middle, &_upperbound, stats );
|
||||
}
|
||||
}
|
||||
return _upperbound;
|
||||
}
|
||||
_forwardHeap.Insert(start, 0, start);
|
||||
_backwardHeap.Insert(target, 0, target);
|
||||
stats.insertedNodes += 2;
|
||||
|
||||
inline unsigned int findNearestNodeForLatLon(const _Coordinate& coord, _Coordinate& result) const
|
||||
{
|
||||
nodeHelpDesk->findNearestNodeCoordForLatLon( coord, result );
|
||||
return 0;
|
||||
while(_forwardHeap.Size() + _backwardHeap.Size() > 0) {
|
||||
if ( _forwardHeap.Size() > 0 ) {
|
||||
_RoutingStepWithStats( _forwardHeap, _backwardHeap, true, &middle, &_upperbound, stats );
|
||||
}
|
||||
if ( _backwardHeap.Size() > 0 ) {
|
||||
_RoutingStepWithStats( _backwardHeap, _forwardHeap, false, &middle, &_upperbound, stats );
|
||||
}
|
||||
}
|
||||
return _upperbound;
|
||||
}
|
||||
|
||||
}
|
||||
inline unsigned int findNearestNodeForLatLon(const _Coordinate& coord, _Coordinate& result) const
|
||||
{
|
||||
nodeHelpDesk->findNearestNodeCoordForLatLon( coord, result );
|
||||
return 0;
|
||||
|
||||
inline bool FindRoutingStarts(const _Coordinate &start, const _Coordinate &target, PhantomNodes & routingStarts) {
|
||||
nodeHelpDesk->FindRoutingStarts(start, target, routingStarts);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
inline bool FindPhantomNodeForCoordinate(const _Coordinate &location, PhantomNode & result) {
|
||||
return nodeHelpDesk->FindPhantomNodeForCoordinate(location, result);
|
||||
}
|
||||
inline bool FindRoutingStarts(const _Coordinate &start, const _Coordinate &target, PhantomNodes & routingStarts) {
|
||||
nodeHelpDesk->FindRoutingStarts(start, target, routingStarts);
|
||||
return true;
|
||||
}
|
||||
|
||||
inline NodeID GetNameIDForOriginDestinationNodeID(NodeID s, NodeID t) const {
|
||||
//INFO("Getting nameID for s=" << s << " and t=" << 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;
|
||||
}
|
||||
inline bool FindPhantomNodeForCoordinate(const _Coordinate &location, PhantomNode & result) {
|
||||
return nodeHelpDesk->FindPhantomNodeForCoordinate(location, result);
|
||||
}
|
||||
|
||||
inline NodeID GetWeightForOriginDestinationNodeID(NodeID s, NodeID t) const {
|
||||
assert(s!=t);
|
||||
EdgeID e = _graph->FindEdge( s, t );
|
||||
if(e == UINT_MAX)
|
||||
e = _graph->FindEdge( t, s );
|
||||
assert(e != UINT_MAX);
|
||||
const EdgeData ed = _graph->GetEdgeData(e);
|
||||
return ed.distance;
|
||||
}
|
||||
inline NodeID GetNameIDForOriginDestinationNodeID(NodeID s, NodeID t) const {
|
||||
//INFO("Getting nameID for s=" << s << " and t=" << 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;
|
||||
}
|
||||
|
||||
inline std::string &GetUnescapedNameForNameID(const NodeID nameID) const {
|
||||
return (nameID >= _names->size() ? _names->at(0) : _names->at(nameID) );
|
||||
}
|
||||
inline NodeID GetWeightForOriginDestinationNodeID(NodeID s, NodeID t) const {
|
||||
assert(s!=t);
|
||||
EdgeID e = _graph->FindEdge( s, t );
|
||||
if(e == UINT_MAX)
|
||||
e = _graph->FindEdge( t, s );
|
||||
assert(e != UINT_MAX);
|
||||
const EdgeData ed = _graph->GetEdgeData(e);
|
||||
return ed.distance;
|
||||
}
|
||||
|
||||
inline std::string GetEscapedNameForOriginDestinationNodeID(NodeID s, NodeID t) const {
|
||||
NodeID nameID = GetNameIDForOriginDestinationNodeID(s, t);
|
||||
return ( GetEscapedNameForNameID(nameID) );
|
||||
}
|
||||
inline std::string &GetUnescapedNameForNameID(const NodeID nameID) const {
|
||||
return (nameID >= _names->size() ? _names->at(0) : _names->at(nameID) );
|
||||
}
|
||||
|
||||
inline std::string GetEscapedNameForNameID(const NodeID nameID) const {
|
||||
return ( (nameID >= _names->size() || nameID == 0) ? std::string("") : HTMLEntitize(_names->at(nameID)) );
|
||||
}
|
||||
inline std::string GetEscapedNameForOriginDestinationNodeID(NodeID s, NodeID t) const {
|
||||
NodeID nameID = GetNameIDForOriginDestinationNodeID(s, t);
|
||||
return ( GetEscapedNameForNameID(nameID) );
|
||||
}
|
||||
|
||||
inline short GetTypeOfEdgeForOriginDestinationNodeID(NodeID s, NodeID t) const {
|
||||
assert(s!=t);
|
||||
EdgeID e = _graph->FindEdge( s, t );
|
||||
if(e == UINT_MAX)
|
||||
e = _graph->FindEdge( t, s );
|
||||
assert(e != UINT_MAX);
|
||||
const EdgeData ed = _graph->GetEdgeData(e);
|
||||
return ed.type;
|
||||
}
|
||||
inline std::string GetEscapedNameForNameID(const NodeID nameID) const {
|
||||
return ( (nameID >= _names->size() || nameID == 0) ? std::string("") : HTMLEntitize(_names->at(nameID)) );
|
||||
}
|
||||
|
||||
// inline void RegisterThread(const unsigned k, const unsigned v) {
|
||||
// nodeHelpDesk->RegisterThread(k,v);
|
||||
// }
|
||||
inline short GetTypeOfEdgeForOriginDestinationNodeID(NodeID s, NodeID t) const {
|
||||
assert(s!=t);
|
||||
EdgeID e = _graph->FindEdge( s, t );
|
||||
if(e == UINT_MAX)
|
||||
e = _graph->FindEdge( t, s );
|
||||
assert(e != UINT_MAX);
|
||||
const EdgeData ed = _graph->GetEdgeData(e);
|
||||
return ed.type;
|
||||
}
|
||||
|
||||
// inline void RegisterThread(const unsigned k, const unsigned v) {
|
||||
// nodeHelpDesk->RegisterThread(k,v);
|
||||
// }
|
||||
private:
|
||||
|
||||
inline void _RoutingStep(_Heap& _forwardHeap, _Heap &_backwardHeap, const bool& forwardDirection, NodeID * middle, unsigned int * _upperbound) {
|
||||
const NodeID node = _forwardHeap.DeleteMin();
|
||||
const unsigned int distance = _forwardHeap.GetKey( node );
|
||||
if ( _backwardHeap.WasInserted( node ) ) {
|
||||
const unsigned int newDistance = _backwardHeap.GetKey( node ) + distance;
|
||||
if ( newDistance < *_upperbound ) {
|
||||
*middle = node;
|
||||
*_upperbound = newDistance;
|
||||
}
|
||||
}
|
||||
if ( distance > *_upperbound ) {
|
||||
_forwardHeap.DeleteAll();
|
||||
return;
|
||||
}
|
||||
inline void _RoutingStep(_Heap& _forwardHeap, _Heap &_backwardHeap, const bool& forwardDirection, NodeID * middle, unsigned int * _upperbound) {
|
||||
const NodeID node = _forwardHeap.DeleteMin();
|
||||
const unsigned int distance = _forwardHeap.GetKey( node );
|
||||
if ( _backwardHeap.WasInserted( node ) ) {
|
||||
const unsigned int newDistance = _backwardHeap.GetKey( node ) + distance;
|
||||
if ( newDistance < *_upperbound ) {
|
||||
*middle = node;
|
||||
*_upperbound = newDistance;
|
||||
}
|
||||
}
|
||||
if ( distance > *_upperbound ) {
|
||||
_forwardHeap.DeleteAll();
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
for ( typename GraphT::EdgeIterator edge = _graph->BeginEdges( node ); edge < _graph->EndEdges(node); edge++ ) {
|
||||
const NodeID to = _graph->GetTarget(edge);
|
||||
const EdgeWeight edgeWeight = _graph->GetEdgeData(edge).distance;
|
||||
for ( typename GraphT::EdgeIterator edge = _graph->BeginEdges( node ); edge < _graph->EndEdges(node); edge++ ) {
|
||||
const NodeID to = _graph->GetTarget(edge);
|
||||
const EdgeWeight edgeWeight = _graph->GetEdgeData(edge).distance;
|
||||
|
||||
assert( edgeWeight > 0 );
|
||||
assert( edgeWeight > 0 );
|
||||
|
||||
//Stalling
|
||||
bool backwardDirectionFlag = (!forwardDirection) ? _graph->GetEdgeData(edge).forward : _graph->GetEdgeData(edge).backward;
|
||||
if(_forwardHeap.WasInserted( to )) {
|
||||
if(backwardDirectionFlag) {
|
||||
if(_forwardHeap.GetKey( to ) + edgeWeight < distance) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for ( typename GraphT::EdgeIterator edge = _graph->BeginEdges( node ); edge < _graph->EndEdges(node); edge++ ) {
|
||||
const NodeID to = _graph->GetTarget(edge);
|
||||
const EdgeWeight edgeWeight = _graph->GetEdgeData(edge).distance;
|
||||
//Stalling
|
||||
bool backwardDirectionFlag = (!forwardDirection) ? _graph->GetEdgeData(edge).forward : _graph->GetEdgeData(edge).backward;
|
||||
if(_forwardHeap.WasInserted( to )) {
|
||||
if(backwardDirectionFlag) {
|
||||
if(_forwardHeap.GetKey( to ) + edgeWeight < distance) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for ( typename GraphT::EdgeIterator edge = _graph->BeginEdges( node ); edge < _graph->EndEdges(node); edge++ ) {
|
||||
const NodeID to = _graph->GetTarget(edge);
|
||||
const EdgeWeight edgeWeight = _graph->GetEdgeData(edge).distance;
|
||||
|
||||
assert( edgeWeight > 0 );
|
||||
const int toDistance = distance + edgeWeight;
|
||||
assert( edgeWeight > 0 );
|
||||
const int toDistance = distance + edgeWeight;
|
||||
|
||||
|
||||
bool forwardDirectionFlag = (forwardDirection ? _graph->GetEdgeData(edge).forward : _graph->GetEdgeData(edge).backward );
|
||||
if(forwardDirectionFlag) {
|
||||
//New Node discovered -> Add to Heap + Node Info Storage
|
||||
if ( !_forwardHeap.WasInserted( to ) ) {
|
||||
_forwardHeap.Insert( to, toDistance, node );
|
||||
}
|
||||
//Found a shorter Path -> Update distance
|
||||
else if ( toDistance < _forwardHeap.GetKey( to ) ) {
|
||||
_forwardHeap.GetData( to ).parent = node;
|
||||
_forwardHeap.DecreaseKey( to, toDistance );
|
||||
//new parent
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
bool forwardDirectionFlag = (forwardDirection ? _graph->GetEdgeData(edge).forward : _graph->GetEdgeData(edge).backward );
|
||||
if(forwardDirectionFlag) {
|
||||
//New Node discovered -> Add to Heap + Node Info Storage
|
||||
if ( !_forwardHeap.WasInserted( to ) ) {
|
||||
_forwardHeap.Insert( to, toDistance, node );
|
||||
}
|
||||
//Found a shorter Path -> Update distance
|
||||
else if ( toDistance < _forwardHeap.GetKey( to ) ) {
|
||||
_forwardHeap.GetData( to ).parent = node;
|
||||
_forwardHeap.DecreaseKey( to, toDistance );
|
||||
//new parent
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline void _RoutingStepWithStats( _Heap& _forwardHeap, _Heap &_backwardHeap, const bool& forwardDirection, NodeID * middle, unsigned int * _upperbound, _Statistics& stats) {
|
||||
const NodeID node = _forwardHeap.DeleteMin();
|
||||
stats.deleteMins++;
|
||||
const unsigned int distance = _forwardHeap.GetKey( node );
|
||||
if ( _backwardHeap.WasInserted( node ) ) {
|
||||
const unsigned int newDistance = _backwardHeap.GetKey( node ) + distance;
|
||||
if ( newDistance < *_upperbound ) {
|
||||
*middle = node;
|
||||
*_upperbound = newDistance;
|
||||
}
|
||||
}
|
||||
if ( distance > *_upperbound ) {
|
||||
stats.meetingNodes++;
|
||||
_forwardHeap.DeleteAll();
|
||||
return;
|
||||
}
|
||||
inline void _RoutingStepWithStats( _Heap& _forwardHeap, _Heap &_backwardHeap, const bool& forwardDirection, NodeID * middle, unsigned int * _upperbound, _Statistics& stats) {
|
||||
const NodeID node = _forwardHeap.DeleteMin();
|
||||
stats.deleteMins++;
|
||||
const unsigned int distance = _forwardHeap.GetKey( node );
|
||||
if ( _backwardHeap.WasInserted( node ) ) {
|
||||
const unsigned int newDistance = _backwardHeap.GetKey( node ) + distance;
|
||||
if ( newDistance < *_upperbound ) {
|
||||
*middle = node;
|
||||
*_upperbound = newDistance;
|
||||
}
|
||||
}
|
||||
if ( distance > *_upperbound ) {
|
||||
stats.meetingNodes++;
|
||||
_forwardHeap.DeleteAll();
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
for ( typename GraphT::EdgeIterator edge = _graph->BeginEdges( node ); edge < _graph->EndEdges(node); edge++ ) {
|
||||
const EdgeData& ed = _graph->GetEdgeData(edge);
|
||||
const NodeID to = _graph->GetTarget(edge);
|
||||
const EdgeWeight edgeWeight = ed.distance;
|
||||
for ( typename GraphT::EdgeIterator edge = _graph->BeginEdges( node ); edge < _graph->EndEdges(node); edge++ ) {
|
||||
const EdgeData& ed = _graph->GetEdgeData(edge);
|
||||
const NodeID to = _graph->GetTarget(edge);
|
||||
const EdgeWeight edgeWeight = ed.distance;
|
||||
|
||||
assert( edgeWeight > 0 );
|
||||
const int toDistance = distance + edgeWeight;
|
||||
assert( edgeWeight > 0 );
|
||||
const int toDistance = distance + edgeWeight;
|
||||
|
||||
//Stalling
|
||||
if(_forwardHeap.WasInserted( to )) {
|
||||
if(!forwardDirection ? ed.forward : ed.backward) {
|
||||
if(_forwardHeap.GetKey( to ) + edgeWeight < distance) {
|
||||
stats.stalledNodes++;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
//Stalling
|
||||
if(_forwardHeap.WasInserted( to )) {
|
||||
if(!forwardDirection ? ed.forward : ed.backward) {
|
||||
if(_forwardHeap.GetKey( to ) + edgeWeight < distance) {
|
||||
stats.stalledNodes++;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(forwardDirection ? ed.forward : ed.backward ) {
|
||||
//New Node discovered -> Add to Heap + Node Info Storage
|
||||
if ( !_forwardHeap.WasInserted( to ) ) {
|
||||
_forwardHeap.Insert( to, toDistance, node );
|
||||
stats.insertedNodes++;
|
||||
}
|
||||
//Found a shorter Path -> Update distance
|
||||
else if ( toDistance < _forwardHeap.GetKey( to ) ) {
|
||||
_forwardHeap.GetData( to ).parent = node;
|
||||
_forwardHeap.DecreaseKey( to, toDistance );
|
||||
stats.decreasedNodes++;
|
||||
//new parent
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(forwardDirection ? ed.forward : ed.backward ) {
|
||||
//New Node discovered -> Add to Heap + Node Info Storage
|
||||
if ( !_forwardHeap.WasInserted( to ) ) {
|
||||
_forwardHeap.Insert( to, toDistance, node );
|
||||
stats.insertedNodes++;
|
||||
}
|
||||
//Found a shorter Path -> Update distance
|
||||
else if ( toDistance < _forwardHeap.GetKey( to ) ) {
|
||||
_forwardHeap.GetData( to ).parent = node;
|
||||
_forwardHeap.DecreaseKey( to, toDistance );
|
||||
stats.decreasedNodes++;
|
||||
//new parent
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline bool _UnpackEdge( const NodeID source, const NodeID target, std::vector< _PathData >& path ) {
|
||||
assert(source != target);
|
||||
//find edge first.
|
||||
bool forward = true;
|
||||
typename GraphT::EdgeIterator smallestEdge = SPECIAL_EDGEID;
|
||||
EdgeWeight smallestWeight = UINT_MAX;
|
||||
for(typename GraphT::EdgeIterator eit = _graph->BeginEdges(source); eit < _graph->EndEdges(source); eit++) {
|
||||
const EdgeWeight weight = _graph->GetEdgeData(eit).distance;
|
||||
if(_graph->GetTarget(eit) == target && weight < smallestWeight && _graph->GetEdgeData(eit).forward) {
|
||||
smallestEdge = eit; smallestWeight = weight;
|
||||
}
|
||||
}
|
||||
if(smallestEdge == SPECIAL_EDGEID) {
|
||||
for(typename GraphT::EdgeIterator eit = _graph->BeginEdges(target); eit < _graph->EndEdges(target); eit++) {
|
||||
const EdgeWeight weight = _graph->GetEdgeData(eit).distance;
|
||||
if(_graph->GetTarget(eit) == source && weight < smallestWeight && _graph->GetEdgeData(eit).backward) {
|
||||
smallestEdge = eit; smallestWeight = weight;
|
||||
forward = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
inline bool _UnpackEdge( const NodeID source, const NodeID target, std::vector< _PathData >& path ) {
|
||||
assert(source != target);
|
||||
//find edge first.
|
||||
bool forward = true;
|
||||
typename GraphT::EdgeIterator smallestEdge = SPECIAL_EDGEID;
|
||||
EdgeWeight smallestWeight = UINT_MAX;
|
||||
for(typename GraphT::EdgeIterator eit = _graph->BeginEdges(source); eit < _graph->EndEdges(source); eit++) {
|
||||
const EdgeWeight weight = _graph->GetEdgeData(eit).distance;
|
||||
if(_graph->GetTarget(eit) == target && weight < smallestWeight && _graph->GetEdgeData(eit).forward) {
|
||||
smallestEdge = eit; smallestWeight = weight;
|
||||
}
|
||||
}
|
||||
if(smallestEdge == SPECIAL_EDGEID) {
|
||||
for(typename GraphT::EdgeIterator eit = _graph->BeginEdges(target); eit < _graph->EndEdges(target); eit++) {
|
||||
const EdgeWeight weight = _graph->GetEdgeData(eit).distance;
|
||||
if(_graph->GetTarget(eit) == source && weight < smallestWeight && _graph->GetEdgeData(eit).backward) {
|
||||
smallestEdge = eit; smallestWeight = weight;
|
||||
forward = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
assert(smallestWeight != SPECIAL_EDGEID); //no edge found. This should not happen at all!
|
||||
assert(smallestWeight != SPECIAL_EDGEID); //no edge found. This should not happen at all!
|
||||
|
||||
const EdgeData& ed = _graph->GetEdgeData(smallestEdge);
|
||||
if(ed.shortcut) {//unpack
|
||||
const NodeID middle = ed.middleName.middle;
|
||||
_UnpackEdge(source, middle, path);
|
||||
_UnpackEdge(middle, target, path);
|
||||
return false;
|
||||
} else {
|
||||
assert(!ed.shortcut);
|
||||
path.push_back(_PathData(target) );
|
||||
return true;
|
||||
}
|
||||
}
|
||||
const EdgeData& ed = _graph->GetEdgeData(smallestEdge);
|
||||
if(ed.shortcut) {//unpack
|
||||
const NodeID middle = ed.middleName.middle;
|
||||
_UnpackEdge(source, middle, path);
|
||||
_UnpackEdge(middle, target, path);
|
||||
return false;
|
||||
} else {
|
||||
assert(!ed.shortcut);
|
||||
path.push_back(_PathData(target) );
|
||||
return true;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#endif /* SEARCHENGINE_H_ */
|
||||
|
||||
@ -140,7 +140,7 @@ public:
|
||||
|
||||
double area = fabs(0.5*( descriptorState.startOfSegmentCoordinate.lon*(descriptorState.nextCoordinate.lat - descriptorState.currentCoordinate.lat) + descriptorState.nextCoordinate.lon*(descriptorState.currentCoordinate.lat - descriptorState.startOfSegmentCoordinate.lat) + descriptorState.currentCoordinate.lon*(descriptorState.startOfSegmentCoordinate.lat - descriptorState.nextCoordinate.lat) ) );
|
||||
//if route is generalization does not skip this point, add it to description
|
||||
if( it==path.end()-1 || config.z == 19 || area >= areaThresholds[config.z] || (false == descriptorState.CurrentAndPreviousNameIDsEqual()) ) {
|
||||
if( config.z == 19 || area >= areaThresholds[config.z] || (false == descriptorState.CurrentAndPreviousNameIDsEqual()) ) {
|
||||
//mark the beginning of the segment thats announced
|
||||
// appendCoordinateToString(descriptorState.currentCoordinate, descriptorState.routeGeometryString);
|
||||
polyline.push_back(descriptorState.currentCoordinate);
|
||||
|
||||
@ -50,22 +50,7 @@ private:
|
||||
HashTable<std::string, unsigned> descriptorTable;
|
||||
std::string pluginDescriptorString;
|
||||
|
||||
struct _ThreadData {
|
||||
SearchEngine<EdgeData, StaticGraph<EdgeData> > * sEngine;
|
||||
std::vector< _PathData > * path;
|
||||
unsigned distanceOfSegment;
|
||||
PhantomNodes phantomNodesOfSegment;
|
||||
_ThreadData(SearchEngine<EdgeData, StaticGraph<EdgeData> > * s) : sEngine(s), distanceOfSegment(0) {
|
||||
path = new std::vector< _PathData >();
|
||||
}
|
||||
~_ThreadData() {
|
||||
DELETE( path );
|
||||
DELETE( sEngine );
|
||||
}
|
||||
};
|
||||
|
||||
std::vector<_ThreadData *> threadData;
|
||||
|
||||
SearchEngine<EdgeData, StaticGraph<EdgeData> > * searchEngine;
|
||||
public:
|
||||
|
||||
ViaRoutePlugin(ObjectsForQueryStruct * objects, std::string psd = "viaroute") : pluginDescriptorString(psd) {
|
||||
@ -73,10 +58,7 @@ public:
|
||||
graph = objects->graph;
|
||||
names = objects->names;
|
||||
|
||||
unsigned maxThreads = omp_get_max_threads();
|
||||
for ( unsigned threadNum = 0; threadNum < maxThreads; ++threadNum ) {
|
||||
threadData.push_back( new _ThreadData( new SearchEngine<EdgeData, StaticGraph<EdgeData> >(graph, nodeHelpDesk, names)) );
|
||||
}
|
||||
searchEngine = new SearchEngine<EdgeData, StaticGraph<EdgeData> >(graph, nodeHelpDesk, names);
|
||||
|
||||
descriptorTable.Set("", 0); //default descriptor
|
||||
descriptorTable.Set("kml", 0);
|
||||
@ -85,9 +67,7 @@ public:
|
||||
}
|
||||
|
||||
virtual ~ViaRoutePlugin() {
|
||||
for ( unsigned threadNum = 0; threadNum < threadData.size(); threadNum++ ) {
|
||||
DELETE( threadData[threadNum] );
|
||||
}
|
||||
DELETE( searchEngine );
|
||||
}
|
||||
|
||||
std::string GetDescriptor() { return pluginDescriptorString; }
|
||||
@ -144,25 +124,22 @@ public:
|
||||
vector<PhantomNode> phantomNodeVector(rawRoute.rawViaNodeCoordinates.size());
|
||||
bool errorOccurredFlag = false;
|
||||
|
||||
#pragma omp parallel for
|
||||
for(unsigned i = 0; i < rawRoute.rawViaNodeCoordinates.size(); i++) {
|
||||
threadData[omp_get_thread_num()]->sEngine->FindPhantomNodeForCoordinate( rawRoute.rawViaNodeCoordinates[i], phantomNodeVector[i]);
|
||||
searchEngine->FindPhantomNodeForCoordinate( rawRoute.rawViaNodeCoordinates[i], phantomNodeVector[i]);
|
||||
if(!rawRoute.rawViaNodeCoordinates[i].isSet()) {
|
||||
errorOccurredFlag = true;
|
||||
}
|
||||
}
|
||||
|
||||
rawRoute.Resize();
|
||||
|
||||
unsigned distance = 0;
|
||||
|
||||
//#pragma omp parallel for reduction(+:distance)
|
||||
for(unsigned i = 0; i < phantomNodeVector.size()-1 && !errorOccurredFlag; i++) {
|
||||
PhantomNodes & segmentPhantomNodes = threadData[omp_get_thread_num()]->phantomNodesOfSegment;
|
||||
PhantomNodes segmentPhantomNodes;
|
||||
segmentPhantomNodes.startPhantom = phantomNodeVector[i];
|
||||
segmentPhantomNodes.targetPhantom = phantomNodeVector[i+1];
|
||||
std::vector< _PathData > path;
|
||||
unsigned distanceOfSegment = threadData[omp_get_thread_num()]->sEngine->ComputeRoute(segmentPhantomNodes, path);
|
||||
unsigned distanceOfSegment = searchEngine->ComputeRoute(segmentPhantomNodes, path);
|
||||
|
||||
if(UINT_MAX == distanceOfSegment ) {
|
||||
errorOccurredFlag = true;
|
||||
@ -229,7 +206,9 @@ public:
|
||||
phantomNodes.startPhantom = rawRoute.segmentEndCoordinates[0].startPhantom;
|
||||
phantomNodes.targetPhantom = rawRoute.segmentEndCoordinates[rawRoute.segmentEndCoordinates.size()-1].targetPhantom;
|
||||
desc->SetConfig(descriptorConfig);
|
||||
desc->Run(reply, rawRoute, phantomNodes, *threadData[0]->sEngine, distance);
|
||||
|
||||
desc->Run(reply, rawRoute, phantomNodes, *searchEngine, distance);
|
||||
|
||||
if("" != JSONParameter) {
|
||||
reply.content += ")\n";
|
||||
}
|
||||
|
||||
@ -46,7 +46,6 @@ public:
|
||||
BasePlugin * tempPointer = _pluginVector[i];
|
||||
DELETE( tempPointer );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void handle_request(const Request& req, Reply& rep){
|
||||
|
||||
Loading…
Reference in New Issue
Block a user