Merging develop branch into master for v0.3.4 release

based generator

.gitignore

@@ -33,11 +33,9 @@ ehthumbs.db
 Icon?
 Thumbs.db
 
-# SCons related files #
+# build related files #
 #######################
-SconsBuilder*
-.scon*
-.build
+/build/
 
 # Eclipse related files #
 #########################
@@ -54,23 +52,23 @@ stxxl.errlog
 
 # compiled protobuffers #
 #########################
-DataStructures/pbf-proto/*.pb.h
-DataStructures/pbf-proto/*.pb.cc
+/DataStructures/pbf-proto/*.pb.h
+/DataStructures/pbf-proto/*.pb.cc
 
 # External Libs #
 #################
-lib/
-win/lib
+/lib/
+/win/lib
 
 # Visual Studio Temp + build Files #
 ####################################
-win/*.user
-win/*.ncb
-win/*.suo
-win/Debug/
-win/Release/
-win/bin/
-win/bin-debug/
+/win/*.user
+/win/*.ncb
+/win/*.suo
+/win/Debug/
+/win/Release/
+/win/bin/
+/win/bin-debug/
 /osrm-extract
 /osrm-routed
 /osrm-prepare
@@ -78,6 +76,7 @@ win/bin-debug/
 
 # Sandbox folder #
 ###################
-sandbox/
+/sandbox/
 
-test/profile.lua
+/test/profile.lua
+/profile.lua

Algorithms/CRC32.h

@@ -27,7 +27,6 @@
 class CRC32 {
 private:
     unsigned crc;
-    unsigned slowcrc_table[1<<8];
 
     typedef boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> my_crc_32_type;
     typedef unsigned (CRC32::*CRC32CFunctionPtr)(char *str, unsigned len, unsigned crc);

Algorithms/IteratorBasedCRC32.h

@@ -30,7 +30,6 @@ class IteratorbasedCRC32 {
 private:
     typedef typename ContainerT::iterator ContainerT_iterator;
     unsigned crc;
-    unsigned slowcrc_table[1<<8];
 
     typedef boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> my_crc_32_type;
     typedef unsigned (IteratorbasedCRC32::*CRC32CFunctionPtr)(char *str, unsigned len, unsigned crc);

Algorithms/ObjectToBase64.h

@@ -33,12 +33,12 @@ or see http://www.gnu.org/licenses/agpl.txt.
 
 typedef
         boost::archive::iterators::base64_from_binary<
-        boost::archive::iterators::transform_width<string::const_iterator, 6, 8>
+        boost::archive::iterators::transform_width<std::string::const_iterator, 6, 8>
 > base64_t;
 
 typedef
         boost::archive::iterators::transform_width<
-        boost::archive::iterators::binary_from_base64<string::const_iterator>, 8, 6
+        boost::archive::iterators::binary_from_base64<std::string::const_iterator>, 8, 6
         > binary_t;
 
 template<class ToEncodeT>
@@ -54,7 +54,7 @@ static void EncodeObjectToBase64(const ToEncodeT & object, std::string& encoded)
 template<class ToEncodeT>
 static void DecodeObjectFromBase64(ToEncodeT & object, const std::string& _encoded) {
     try {
-        string encoded(_encoded);
+    	std::string encoded(_encoded);
         //replace "-" with "+" and "_" with "/"
         replaceAll(encoded, "-", "+");
         replaceAll(encoded, "_", "/");

Algorithms/StronglyConnectedComponents.h

@@ -52,21 +52,12 @@ private:
         unsigned edgeBasedNodeID;
         unsigned nameID:31;
         bool shortcut:1;
+        short type;
+        bool isAccessRestricted:1;
         bool forward:1;
         bool backward:1;
         bool roundabout:1;
         bool ignoreInGrid:1;
-        short type;
-        bool isAccessRestricted;
-    };
-
-    struct _EdgeBasedEdgeData {
-        int distance;
-        unsigned via;
-        unsigned nameID;
-        bool forward;
-        bool backward;
-        TurnInstruction turnInstruction;
     };
 
     typedef DynamicGraph< _NodeBasedEdgeData > _NodeBasedDynamicGraph;

CMakeLists.txt

@@ -0,0 +1,111 @@
+cmake_minimum_required(VERSION 2.6)
+project(OSRM)
+include(FindPackageHandleStandardArgs)
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+set(BOOST_COMPONENTS filesystem regex system thread)
+
+file(GLOB ExtractorGlob Extractor/*.cpp)
+set(ExtractorSources extractor.cpp ${ExtractorGlob})
+add_executable(osrm-extract ${ExtractorSources})
+
+file(GLOB PrepareGlob Contractor/*.cpp)
+set(PrepareSources createHierarchy.cpp ${PrepareGlob})
+add_executable(osrm-prepare ${PrepareSources})
+
+file(GLOB RoutedGlob Server/DataStructures/*.cpp Descriptors/*.cpp DataStructures/SearchEngine*.cpp)
+set(RoutedSources routed.cpp ${RoutedGlob})
+add_executable(osrm-routed ${RoutedSources})
+set_target_properties(osrm-routed PROPERTIES COMPILE_FLAGS -DROUTED)
+
+# Check the release mode
+if(NOT CMAKE_BUILD_TYPE MATCHES Debug)
+	set(CMAKE_BUILD_TYPE Release)
+endif(NOT CMAKE_BUILD_TYPE MATCHES Debug) 
+if(CMAKE_BUILD_TYPE MATCHES Debug)
+    message(STATUS "Configuring OSRM in debug mode")
+endif(CMAKE_BUILD_TYPE MATCHES Debug) 
+if(CMAKE_BUILD_TYPE MATCHES Release)
+    message(STATUS "Configuring OSRM in release mode")
+endif(CMAKE_BUILD_TYPE MATCHES Release) 
+
+#Configuring compilers
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+	# using Clang
+	set(CMAKE_CXX_FLAGS "-Wall -Wno-unknown-pragmas -Wno-unneeded-internal-declaration")
+	message(STATUS "OpenMP parallelization not available using clang++")
+elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+	# using GCC
+	set(CMAKE_CXX_FLAGS "-Wall -fopenmp -pedantic") 
+elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
+	# using Intel C++
+	set(CMAKE_CXX_FLAGS "-static-intel -wd10237 -Wall -openmp -ipo")
+elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+	# using Visual Studio C++
+endif()
+
+if(APPLE)
+	SET(CMAKE_OSX_ARCHITECTURES "x86_64")
+	message("Set Architecture to x64 on OS X")
+endif()
+
+#Check Boost
+set(BOOST_MIN_VERSION "1.44.0")
+find_package( Boost ${BOOST_MIN_VERSION} COMPONENTS ${BOOST_COMPONENTS} REQUIRED )
+if (NOT Boost_FOUND)
+      message(FATAL_ERROR "Fatal error: Boost (version >= 1.44.0) required.\n")
+endif (NOT Boost_FOUND)
+include_directories(${Boost_INCLUDE_DIRS})
+target_link_libraries( osrm-extract ${Boost_LIBRARIES} )
+target_link_libraries( osrm-prepare ${Boost_LIBRARIES} )
+target_link_libraries( osrm-routed ${Boost_LIBRARIES} )
+
+find_package ( BZip2 REQUIRED )
+include_directories(${BZIP_INCLUDE_DIRS})
+target_link_libraries (osrm-extract ${BZIP2_LIBRARIES})
+
+find_package( ZLIB REQUIRED )
+target_link_libraries (osrm-extract ${ZLIB_LIBRARY})
+target_link_libraries (osrm-routed ${ZLIB_LIBRARY})
+
+find_package( Threads REQUIRED )
+target_link_libraries (osrm-extract ${Threads_LIBRARY})
+
+find_package( Lua51 REQUIRED ) 
+include_directories(${LUA_INCLUDE_DIR})
+target_link_libraries( osrm-extract ${LUA_LIBRARY} )
+target_link_libraries( osrm-prepare ${LUA_LIBRARY} )
+
+find_package( LibXml2 REQUIRED )
+include_directories(${LIBXML2_INCLUDE_DIR})
+target_link_libraries (osrm-extract ${LIBXML2_LIBRARIES})
+
+find_package( Luabind REQUIRED )
+include_directories(${LUABIND_INCLUDE_DIR})
+target_link_libraries (osrm-extract ${LUABIND_LIBRARY})
+target_link_libraries (osrm-prepare ${LUABIND_LIBRARY})
+
+find_package( Protobuf REQUIRED )
+include_directories(${PROTOBUF_INCLUDE_DIRS})
+target_link_libraries (osrm-extract ${PROTOBUF_LIBRARY})
+target_link_libraries (osrm-prepare ${PROTOBUF_LIBRARY})
+
+find_package( STXXL REQUIRED )
+include_directories(${STXXL_INCLUDE_DIR})
+target_link_libraries (osrm-extract ${STXXL_LIBRARY})
+target_link_libraries (osrm-prepare ${STXXL_LIBRARY})
+
+find_package( OSMPBF REQUIRED )
+include_directories(${OSMPBF_INCLUDE_DIR})
+target_link_libraries (osrm-extract ${OSMPBF_LIBRARY})
+target_link_libraries (osrm-prepare ${OSMPBF_LIBRARY})
+
+if(WITH_TOOLS)
+	message("-- Activating OSRM internal tools")
+	find_package( GDAL )
+	if(GDAL_FOUND)
+		add_executable(osrm-components Tools/componentAnalysis.cpp)
+		include_directories(${GDAL_INCLUDE_DIR})
+		target_link_libraries( osrm-components ${GDAL_LIBRARIES} )
+		target_link_libraries( osrm-components ${Boost_LIBRARIES} )
+	endif(GDAL_FOUND)
+endif(WITH_TOOLS)

Contractor/Contractor.h

@@ -20,17 +20,6 @@ or see http://www.gnu.org/licenses/agpl.txt.
 
 #ifndef CONTRACTOR_H_INCLUDED
 #define CONTRACTOR_H_INCLUDED
-#include <algorithm>
-#include <limits>
-#include <vector>
-
-#include <cfloat>
-#include <ctime>
-
-#include <boost/foreach.hpp>
-#include <boost/lambda/lambda.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/shared_ptr.hpp>
 
 #include "TemporaryStorage.h"
 #include "../DataStructures/BinaryHeap.h"
@@ -42,6 +31,19 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include "../Util/OpenMPWrapper.h"
 #include "../Util/StringUtil.h"
 
+#include <boost/assert.hpp>
+#include <boost/foreach.hpp>
+#include <boost/lambda/lambda.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include <cfloat>
+#include <ctime>
+
+#include <algorithm>
+#include <limits>
+#include <vector>
+
 class Contractor {
 
 private:
@@ -119,7 +121,7 @@ public:
             newEdge.target = diter->target();
             newEdge.data = _ContractorEdgeData( (std::max)((int)diter->weight(), 1 ),  1,  diter->id(),  false,  diter->isForward(),  diter->isBackward());
 
-            assert( newEdge.data.distance > 0 );
+            BOOST_ASSERT_MSG( newEdge.data.distance > 0, "edge distance < 1" );
 #ifndef NDEBUG
             if ( newEdge.data.distance > 24 * 60 * 60 * 10 ) {
                 WARN("Edge weight large -> " << newEdge.data.distance);
@@ -157,11 +159,13 @@ public:
             forwardEdge.data.distance = backwardEdge.data.distance = std::numeric_limits< int >::max();
             //remove parallel edges
             while ( i < edges.size() && edges[i].source == source && edges[i].target == target ) {
-                if ( edges[i].data.forward )
+            	if ( edges[i].data.forward) {
                     forwardEdge.data.distance = std::min( edges[i].data.distance, forwardEdge.data.distance );
-                if ( edges[i].data.backward )
+                }
+                if ( edges[i].data.backward) {
                     backwardEdge.data.distance = std::min( edges[i].data.distance, backwardEdge.data.distance );
-                i++;
+                }
+                ++i;
             }
             //merge edges (s,t) and (t,s) into bidirectional edge
             if ( forwardEdge.data.distance == backwardEdge.data.distance ) {
@@ -230,8 +234,9 @@ public:
 
         //initialize the variables
 #pragma omp parallel for schedule ( guided )
-        for ( int x = 0; x < ( int ) numberOfNodes; ++x )
+        for ( int x = 0; x < ( int ) numberOfNodes; ++x ) {
             remainingNodes[x].id = x;
+        }
 
         std::cout << "initializing elimination PQ ..." << std::flush;
 #pragma omp parallel
@@ -242,10 +247,10 @@ public:
                 nodePriority[x] = _Evaluate( data, &nodeData[x], x );
             }
         }
-        std::cout << "ok" << std::endl << "preprocessing ..." << std::flush;
+        std::cout << "ok" << std::endl << "preprocessing " << numberOfNodes << " nodes ..." << std::flush;
 
         bool flushedContractor = false;
-        while ( numberOfContractedNodes < numberOfNodes ) {
+        while ( numberOfNodes > 2 && numberOfContractedNodes < numberOfNodes ) {
             if(!flushedContractor && (numberOfContractedNodes > (numberOfNodes*0.65) ) ){
                 DeallocatingVector<_ContractorEdge> newSetOfEdges; //this one is not explicitely cleared since it goes out of scope anywa
                 std::cout << " [flush " << numberOfContractedNodes << " nodes] " << std::flush;
@@ -274,13 +279,12 @@ public:
                 TemporaryStorage & tempStorage = TemporaryStorage::GetInstance();
                 //Write dummy number of edges to temporary file
                 //        		std::ofstream temporaryEdgeStorage(temporaryEdgeStorageFilename.c_str(), std::ios::binary);
-                long initialFilePosition = tempStorage.tell(temporaryStorageSlotID);
+                uint64_t initialFilePosition = tempStorage.tell(temporaryStorageSlotID);
                 unsigned numberOfTemporaryEdges = 0;
                 tempStorage.writeToSlot(temporaryStorageSlotID, (char*)&numberOfTemporaryEdges, sizeof(unsigned));
 
                 //walk over all nodes
                 for(unsigned i = 0; i < _graph->GetNumberOfNodes(); ++i) {
-                    //INFO("Restructuring node " << i << "|" << _graph->GetNumberOfNodes());
                     const NodeID start = i;
                     for(_DynamicGraph::EdgeIterator currentEdge = _graph->BeginEdges(start); currentEdge < _graph->EndEdges(start); ++currentEdge) {
                         _DynamicGraph::EdgeData & data = _graph->GetEdgeData(currentEdge);
@@ -299,8 +303,14 @@ public:
                             newEdge.target = newNodeIDFromOldNodeIDMap[target];
                             newEdge.data = data;
                             newEdge.data.originalViaNodeID = true;
-                            assert(UINT_MAX != newNodeIDFromOldNodeIDMap[start] );
-                            assert(UINT_MAX != newNodeIDFromOldNodeIDMap[target]);
+                            BOOST_ASSERT_MSG(
+                                UINT_MAX != newNodeIDFromOldNodeIDMap[start],
+                                "new start id not resolveable"
+                            );
+                            BOOST_ASSERT_MSG(
+                                UINT_MAX != newNodeIDFromOldNodeIDMap[target],
+                                "new target id not resolveable"
+                            );
                             newSetOfEdges.push_back(newEdge);
                         }
                     }
@@ -309,8 +319,6 @@ public:
                 tempStorage.seek(temporaryStorageSlotID, initialFilePosition);
                 tempStorage.writeToSlot(temporaryStorageSlotID, (char*)&numberOfTemporaryEdges, sizeof(unsigned));
 
-                //        		INFO("Flushed " << numberOfTemporaryEdges << " edges to disk");
-
                 //Delete map from old NodeIDs to new ones.
                 std::vector<NodeID>().swap(newNodeIDFromOldNodeIDMap);
 
@@ -436,38 +444,48 @@ public:
         Percent p (_graph->GetNumberOfNodes());
         INFO("Getting edges of minimized graph");
         NodeID numberOfNodes = _graph->GetNumberOfNodes();
-        if(oldNodeIDFromNewNodeIDMap.size()) {
+        if(_graph->GetNumberOfNodes()) {
             for ( NodeID node = 0; node < numberOfNodes; ++node ) {
                 p.printStatus(node);
                 for ( _DynamicGraph::EdgeIterator edge = _graph->BeginEdges( node ), endEdges = _graph->EndEdges( node ); edge < endEdges; ++edge ) {
                     const NodeID target = _graph->GetTarget( edge );
                     const _DynamicGraph::EdgeData& data = _graph->GetEdgeData( edge );
                     Edge newEdge;
-                    newEdge.source = oldNodeIDFromNewNodeIDMap[node];
-                    newEdge.target = oldNodeIDFromNewNodeIDMap[target];
-                    assert(UINT_MAX != newEdge.source);
-                    assert(UINT_MAX != newEdge.target);
-
+                    if(0 != oldNodeIDFromNewNodeIDMap.size()) {
+                        newEdge.source = oldNodeIDFromNewNodeIDMap[node];
+                        newEdge.target = oldNodeIDFromNewNodeIDMap[target];
+                    } else {
+                        newEdge.source = node;
+                        newEdge.target = target;
+                    }
+                    BOOST_ASSERT_MSG(
+                        UINT_MAX != newEdge.source,
+                        "Source id invalid"
+                    );
+                    BOOST_ASSERT_MSG(
+                        UINT_MAX != newEdge.target,
+                        "Target id invalid"
+                    );
                     newEdge.data.distance = data.distance;
                     newEdge.data.shortcut = data.shortcut;
-                    if(!data.originalViaNodeID)
+                   if(!data.originalViaNodeID && oldNodeIDFromNewNodeIDMap.size()) {
                         newEdge.data.id = oldNodeIDFromNewNodeIDMap[data.id];
-                    else
+                    } else {
                         newEdge.data.id = data.id;
-
-                    assert(newEdge.data.id != UINT_MAX);
+                    }
+                    BOOST_ASSERT_MSG(
+                        newEdge.data.id <= INT_MAX, //2^31
+                        "edge id invalid"
+                    );
                     newEdge.data.forward = data.forward;
                     newEdge.data.backward = data.backward;
                     edges.push_back( newEdge );
                 }
             }
         }
-        INFO("Renumbered edges of minimized graph, freeing space");
         _graph.reset();
         std::vector<NodeID>().swap(oldNodeIDFromNewNodeIDMap);
-        INFO("Loading temporary edges");
 
-        //        std::ifstream temporaryEdgeStorage(temporaryEdgeStorageFilename.c_str(), std::ios::binary);
         TemporaryStorage & tempStorage = TemporaryStorage::GetInstance();
         //Also get the edges from temporary storage
         unsigned numberOfTemporaryEdges = 0;
@@ -492,7 +510,6 @@ public:
             edges.push_back( newEdge );
         }
         tempStorage.deallocateSlot(temporaryStorageSlotID);
-        INFO("Hierarchy has " << edges.size() << " edges");
     }
 
 private:
@@ -515,24 +532,27 @@ private:
 
             if ( heap.GetData( node ).target ) {
                 ++targetsFound;
-                if ( targetsFound >= numTargets )
+                if ( targetsFound >= numTargets ) {
                     return;
+                }
             }
 
             //iterate over all edges of node
             for ( _DynamicGraph::EdgeIterator edge = _graph->BeginEdges( node ), endEdges = _graph->EndEdges( node ); edge != endEdges; ++edge ) {
                 const _ContractorEdgeData& data = _graph->GetEdgeData( edge );
-                if ( !data.forward )
+                if ( !data.forward ){
                     continue;
+                }
                 const NodeID to = _graph->GetTarget( edge );
-                if(middleNode == to)
+                if(middleNode == to) {
                     continue;
+                }
                 const int toDistance = distance + data.distance;
 
                 //New Node discovered -> Add to Heap + Node Info Storage
-                if ( !heap.WasInserted( to ) )
+                if ( !heap.WasInserted( to ) ) {
                     heap.Insert( to, toDistance, _HeapData(currentHop, false) );
-
+                }
                 //Found a shorter Path -> Update distance
                 else if ( toDistance < heap.GetKey( to ) ) {
                     heap.DecreaseKey( to, toDistance );
@@ -582,8 +602,9 @@ private:
 
             for ( _DynamicGraph::EdgeIterator outEdge = _graph->BeginEdges( node ), endOutEdges = _graph->EndEdges( node ); outEdge != endOutEdges; ++outEdge ) {
                 const _ContractorEdgeData& outData = _graph->GetEdgeData( outEdge );
-                if ( !outData.forward )
+                if ( !outData.forward ) {
                     continue;
+                }
                 const NodeID target = _graph->GetTarget( outEdge );
                 const int pathDistance = inData.distance + outData.distance;
                 maxDistance = std::max( maxDistance, pathDistance );
@@ -593,15 +614,16 @@ private:
                 }
             }
 
-            if( Simulate )
+            if( Simulate ) {
                 _Dijkstra( maxDistance, numTargets, 1000, data, node );
-            else
+            } else {
                 _Dijkstra( maxDistance, numTargets, 2000, data, node );
-
+            }
             for ( _DynamicGraph::EdgeIterator outEdge = _graph->BeginEdges( node ), endOutEdges = _graph->EndEdges( node ); outEdge != endOutEdges; ++outEdge ) {
                 const _ContractorEdgeData& outData = _graph->GetEdgeData( outEdge );
-                if ( !outData.forward )
+                if ( !outData.forward ) {
                     continue;
+                }
                 const NodeID target = _graph->GetTarget( outEdge );
                 const int pathDistance = inData.distance + outData.distance;
                 const int distance = heap.GetKey( target );
@@ -641,8 +663,9 @@ private:
                     found = true;
                     break;
                 }
-                if ( !found )
+                if ( !found ) {
                     insertedEdges[insertedEdgesSize++] = insertedEdges[i];
+                }
             }
             insertedEdges.resize( insertedEdgesSize );
         }

Contractor/EdgeBasedGraphFactory.cpp

@@ -21,8 +21,8 @@
 #include "EdgeBasedGraphFactory.h"
 
 template<>
-EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<NodeBasedEdge> & inputEdges, std::vector<NodeID> & bn, std::vector<NodeID> & tl, std::vector<_Restriction> & irs, std::vector<NodeInfo> & nI, SpeedProfileProperties sp) : inputNodeInfoList(nI), numberOfTurnRestrictions(irs.size()), speedProfile(sp) {
-	BOOST_FOREACH(_Restriction & restriction, irs) {
+EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<NodeBasedEdge> & inputEdges, std::vector<NodeID> & bn, std::vector<NodeID> & tl, std::vector<_Restriction> & irs, std::vector<NodeInfo> & nI, SpeedProfileProperties sp) : speedProfile(sp), inputNodeInfoList(nI), numberOfTurnRestrictions(irs.size()) {
+	BOOST_FOREACH(const _Restriction & restriction, irs) {
         std::pair<NodeID, NodeID> restrictionSource = std::make_pair(restriction.fromNode, restriction.viaNode);
         unsigned index;
         RestrictionMap::iterator restrIter = _restrictionMap.find(restrictionSource);
@@ -44,18 +44,12 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<NodeBasedEdg
         _restrictionBucketVector.at(index).push_back(std::make_pair(restriction.toNode, restriction.flags.isOnly));
     }
 
-    BOOST_FOREACH(NodeID id, bn) {
-        _barrierNodes[id] = true;
-    }
-    BOOST_FOREACH(NodeID id, tl) {
-        _trafficLights[id] = true;
-    }
+	_barrierNodes.insert(bn.begin(), bn.end());
+	_trafficLights.insert(tl.begin(), tl.end());
 
     DeallocatingVector< _NodeBasedEdge > edges;
-    //    edges.reserve( 2 * inputEdges.size() );
+    _NodeBasedEdge edge;
     for ( std::vector< NodeBasedEdge >::const_iterator i = inputEdges.begin(); i != inputEdges.end(); ++i ) {
-
-        _NodeBasedEdge edge;
         if(!i->isForward()) {
             edge.source = i->target();
             edge.target = i->source();
@@ -67,9 +61,9 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<NodeBasedEdg
             edge.data.forward = i->isForward();
             edge.data.backward = i->isBackward();
         }
-        if(edge.source == edge.target)
-            continue;
-
+        if(edge.source == edge.target) {
+        	continue;
+        }
         edge.data.distance = (std::max)((int)i->weight(), 1 );
         assert( edge.data.distance > 0 );
         edge.data.shortcut = false;
@@ -79,6 +73,7 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<NodeBasedEdg
         edge.data.type = i->type();
         edge.data.isAccessRestricted = i->isAccessRestricted();
         edge.data.edgeBasedNodeID = edges.size();
+        edge.data.contraFlow = i->isContraFlow();
         edges.push_back( edge );
         if( edge.data.backward ) {
             std::swap( edge.source, edge.target );
@@ -94,11 +89,14 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<NodeBasedEdg
 }
 
 void EdgeBasedGraphFactory::GetEdgeBasedEdges(DeallocatingVector< EdgeBasedEdge >& outputEdgeList ) {
-    GUARANTEE(0 == outputEdgeList.size(), "Vector passed to EdgeBasedGraphFactory::GetEdgeBasedEdges(..) is not empty");
+    BOOST_ASSERT_MSG(
+        0 == outputEdgeList.size(),
+        "Vector is not empty"
+    );
     edgeBasedEdges.swap(outputEdgeList);
 }
 
-void EdgeBasedGraphFactory::GetEdgeBasedNodes( DeallocatingVector< EdgeBasedNode> & nodes) {
+void EdgeBasedGraphFactory::GetEdgeBasedNodes( std::vector<EdgeBasedNode> & nodes) {
 #ifndef NDEBUG
     BOOST_FOREACH(EdgeBasedNode & node, edgeBasedNodes){
         assert(node.lat1 != INT_MAX); assert(node.lon1 != INT_MAX);
@@ -108,16 +106,12 @@ void EdgeBasedGraphFactory::GetEdgeBasedNodes( DeallocatingVector< EdgeBasedNode
     nodes.swap(edgeBasedNodes);
 }
 
-void EdgeBasedGraphFactory::GetOriginalEdgeData( std::vector< OriginalEdgeData> & oed) {
-    oed.swap(originalEdgeData);
-}
-
 NodeID EdgeBasedGraphFactory::CheckForEmanatingIsOnlyTurn(const NodeID u, const NodeID v) const {
     std::pair < NodeID, NodeID > restrictionSource = std::make_pair(u, v);
     RestrictionMap::const_iterator restrIter = _restrictionMap.find(restrictionSource);
     if (restrIter != _restrictionMap.end()) {
         unsigned index = restrIter->second;
-        BOOST_FOREACH(RestrictionSource restrictionTarget, _restrictionBucketVector.at(index)) {
+        BOOST_FOREACH(const RestrictionSource & restrictionTarget, _restrictionBucketVector.at(index)) {
             if(restrictionTarget.second) {
                 return restrictionTarget.first;
             }
@@ -159,7 +153,7 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
     edgeBasedNodes.push_back(currentNode);
 }
 
-void EdgeBasedGraphFactory::Run(const char * originalEdgeDataFilename) {
+void EdgeBasedGraphFactory::Run(const char * originalEdgeDataFilename, lua_State *myLuaState) {
     Percent p(_nodeBasedGraph->GetNumberOfNodes());
     int numberOfSkippedTurns(0);
     int nodeBasedEdgeCounter(0);
@@ -243,12 +237,16 @@ void EdgeBasedGraphFactory::Run(const char * originalEdgeDataFilename) {
     std::vector<NodeID>().swap(vectorOfComponentSizes);
     std::vector<NodeID>().swap(componentsIndex);
 
+    std::vector<OriginalEdgeData> original_edge_data_vector;
+    original_edge_data_vector.reserve(10000);
+
     //Loop over all turns and generate new set of edges.
     //Three nested loop look super-linear, but we are dealing with a linear number of turns only.
     for(_NodeBasedDynamicGraph::NodeIterator u = 0; u < _nodeBasedGraph->GetNumberOfNodes(); ++u ) {
         for(_NodeBasedDynamicGraph::EdgeIterator e1 = _nodeBasedGraph->BeginEdges(u); e1 < _nodeBasedGraph->EndEdges(u); ++e1) {
             ++nodeBasedEdgeCounter;
             _NodeBasedDynamicGraph::NodeIterator v = _nodeBasedGraph->GetTarget(e1);
+            bool isBollardNode = (_barrierNodes.find(v) != _barrierNodes.end());
             //EdgeWeight heightPenalty = ComputeHeightPenalty(u, v);
             NodeID onlyToNode = CheckForEmanatingIsOnlyTurn(u, v);
             for(_NodeBasedDynamicGraph::EdgeIterator e2 = _nodeBasedGraph->BeginEdges(v); e2 < _nodeBasedGraph->EndEdges(v); ++e2) {
@@ -258,7 +256,7 @@ void EdgeBasedGraphFactory::Run(const char * originalEdgeDataFilename) {
                     ++numberOfSkippedTurns;
                     continue;
                 }
-                bool isBollardNode = (_barrierNodes.find(v) != _barrierNodes.end());
+
                 if(u == w && 1 != _nodeBasedGraph->GetOutDegree(v) ) {
                     continue;
                 }
@@ -278,30 +276,30 @@ void EdgeBasedGraphFactory::Run(const char * originalEdgeDataFilename) {
                         if(_trafficLights.find(v) != _trafficLights.end()) {
                             distance += speedProfile.trafficSignalPenalty;
                         }
-                        TurnInstruction turnInstruction = AnalyzeTurn(u, v, w);
+                        unsigned penalty = 0;
+                        TurnInstruction turnInstruction = AnalyzeTurn(u, v, w, penalty, myLuaState);
                         if(turnInstruction == TurnInstructions.UTurn)
                             distance += speedProfile.uTurnPenalty;
 //                        if(!edgeData1.isAccessRestricted && edgeData2.isAccessRestricted) {
 //                            distance += TurnInstructions.AccessRestrictionPenalty;
 //                            turnInstruction |= TurnInstructions.AccessRestrictionFlag;
 //                        }
+                        distance += penalty;
 
 
                         //distance += heightPenalty;
                         //distance += ComputeTurnPenalty(u, v, w);
                         assert(edgeData1.edgeBasedNodeID != edgeData2.edgeBasedNodeID);
-                        if(originalEdgeData.size() == originalEdgeData.capacity()-3) {
-                            originalEdgeData.reserve(originalEdgeData.size()*1.2);
-                        }
                         OriginalEdgeData oed(v,edgeData2.nameID, turnInstruction);
-                        EdgeBasedEdge newEdge(edgeData1.edgeBasedNodeID, edgeData2.edgeBasedNodeID, edgeBasedEdges.size(), distance, true, false );
-                        originalEdgeData.push_back(oed);
-                        if(originalEdgeData.size() > 100000) {
-                            originalEdgeDataOutFile.write((char*)&(originalEdgeData[0]), originalEdgeData.size()*sizeof(OriginalEdgeData));
-                            originalEdgeData.clear();
-                        }
+                        original_edge_data_vector.push_back(oed);
                         ++numberOfOriginalEdges;
-                        ++nodeBasedEdgeCounter;
+
+                        if(original_edge_data_vector.size() > 100000) {
+                            originalEdgeDataOutFile.write((char*)&(original_edge_data_vector[0]), original_edge_data_vector.size()*sizeof(OriginalEdgeData));
+                            original_edge_data_vector.clear();
+                        }
+
+                        EdgeBasedEdge newEdge(edgeData1.edgeBasedNodeID, edgeData2.edgeBasedNodeID, edgeBasedEdges.size(), distance, true, false );
                         edgeBasedEdges.push_back(newEdge);
                     } else {
                         ++numberOfSkippedTurns;
@@ -311,8 +309,7 @@ void EdgeBasedGraphFactory::Run(const char * originalEdgeDataFilename) {
         }
         p.printIncrement();
     }
-    numberOfOriginalEdges += originalEdgeData.size();
-    originalEdgeDataOutFile.write((char*)&(originalEdgeData[0]), originalEdgeData.size()*sizeof(OriginalEdgeData));
+    originalEdgeDataOutFile.write((char*)&(original_edge_data_vector[0]), original_edge_data_vector.size()*sizeof(OriginalEdgeData));
     originalEdgeDataOutFile.seekp(std::ios::beg);
     originalEdgeDataOutFile.write((char*)&numberOfOriginalEdges, sizeof(unsigned));
     originalEdgeDataOutFile.close();
@@ -326,12 +323,27 @@ void EdgeBasedGraphFactory::Run(const char * originalEdgeDataFilename) {
 //    std::vector<EdgeBasedNode>(edgeBasedNodes).swap(edgeBasedNodes);
 //    INFO("size: " << edgeBasedNodes.size() << ", cap: " << edgeBasedNodes.capacity());
     INFO("Node-based graph contains " << nodeBasedEdgeCounter     << " edges");
+    INFO("Edge-based graph contains " << edgeBasedEdges.size()    << " edges");
 //    INFO("Edge-based graph contains " << edgeBasedEdges.size()    << " edges, blowup is " << 2*((double)edgeBasedEdges.size()/(double)nodeBasedEdgeCounter));
     INFO("Edge-based graph skipped "  << numberOfSkippedTurns     << " turns, defined by " << numberOfTurnRestrictions << " restrictions.");
     INFO("Generated " << edgeBasedNodes.size() << " edge based nodes");
 }
 
-TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(const NodeID u, const NodeID v, const NodeID w) const {
+TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(const NodeID u, const NodeID v, const NodeID w, unsigned& penalty, lua_State *myLuaState) const {
+    const double angle = GetAngleBetweenTwoEdges(inputNodeInfoList[u], inputNodeInfoList[v], inputNodeInfoList[w]);
+
+    if( speedProfile.has_turn_penalty_function ) {
+    	try {
+            //call lua profile to compute turn penalty
+            penalty = luabind::call_function<int>( myLuaState, "turn_function", 180-angle );
+        } catch (const luabind::error &er) {
+            std::cerr << er.what() << std::endl;
+            //TODO handle lua errors
+        }
+    } else {
+        penalty = 0;
+    }
+
     if(u == w) {
         return TurnInstructions.UTurn;
     }
@@ -342,33 +354,42 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(const NodeID u, const NodeID
     _NodeBasedDynamicGraph::EdgeData & data1 = _nodeBasedGraph->GetEdgeData(edge1);
     _NodeBasedDynamicGraph::EdgeData & data2 = _nodeBasedGraph->GetEdgeData(edge2);
 
+    if(!data1.contraFlow && data2.contraFlow) {
+    	return TurnInstructions.EnterAgainstAllowedDirection;
+    }
+    if(data1.contraFlow && !data2.contraFlow) {
+    	return TurnInstructions.LeaveAgainstAllowedDirection;
+    }
+
     //roundabouts need to be handled explicitely
     if(data1.roundabout && data2.roundabout) {
         //Is a turn possible? If yes, we stay on the roundabout!
         if( 1 == (_nodeBasedGraph->EndEdges(v) - _nodeBasedGraph->BeginEdges(v)) ) {
             //No turn possible.
             return TurnInstructions.NoTurn;
-        } else {
-            return TurnInstructions.StayOnRoundAbout;
         }
+        return TurnInstructions.StayOnRoundAbout;
     }
     //Does turn start or end on roundabout?
     if(data1.roundabout || data2.roundabout) {
         //We are entering the roundabout
-        if( (!data1.roundabout) && data2.roundabout)
+        if( (!data1.roundabout) && data2.roundabout) {
             return TurnInstructions.EnterRoundAbout;
+        }
         //We are leaving the roundabout
-        else if(data1.roundabout && (!data2.roundabout) )
+        if(data1.roundabout && (!data2.roundabout) ) {
             return TurnInstructions.LeaveRoundAbout;
+        }
     }
 
     //If street names stay the same and if we are certain that it is not a roundabout, we skip it.
-    if( (data1.nameID == data2.nameID) && (0 != data1.nameID))
+    if( (data1.nameID == data2.nameID) && (0 != data1.nameID)) {
         return TurnInstructions.NoTurn;
-    if( (data1.nameID == data2.nameID) && (0 == data1.nameID) && (_nodeBasedGraph->GetOutDegree(v) <= 2) )
+    }
+    if( (data1.nameID == data2.nameID) && (0 == data1.nameID) && (_nodeBasedGraph->GetOutDegree(v) <= 2) ) {
         return TurnInstructions.NoTurn;
+    }
 
-    double angle = GetAngleBetweenTwoEdges(inputNodeInfoList[u], inputNodeInfoList[v], inputNodeInfoList[w]);
     return TurnInstructions.GetTurnDirectionOfInstruction(angle);
 }
 
@@ -379,12 +400,12 @@ unsigned EdgeBasedGraphFactory::GetNumberOfNodes() const {
 /* Get angle of line segment (A,C)->(C,B), atan2 magic, formerly cosine theorem*/
 template<class CoordinateT>
 double EdgeBasedGraphFactory::GetAngleBetweenTwoEdges(const CoordinateT& A, const CoordinateT& C, const CoordinateT& B) const {
-    const int v1x = A.lon - C.lon;
-    const int v1y = A.lat - C.lat;
-    const int v2x = B.lon - C.lon;
-    const int v2y = B.lat - C.lat;
+    const double v1x = (A.lon - C.lon)/100000.;
+    const double v1y = lat2y(A.lat/100000.) - lat2y(C.lat/100000.);
+    const double v2x = (B.lon - C.lon)/100000.;
+    const double v2y = lat2y(B.lat/100000.) - lat2y(C.lat/100000.);
 
-    double angle = (atan2((double)v2y,v2x) - atan2((double)v1y,v1x) )*180/M_PI;
+    double angle = (atan2(v2y,v2x) - atan2(v1y,v1x) )*180/M_PI;
     while(angle < 0)
         angle += 360;
     return angle;

Contractor/EdgeBasedGraphFactory.h

@@ -25,42 +25,88 @@
 #ifndef EDGEBASEDGRAPHFACTORY_H_
 #define EDGEBASEDGRAPHFACTORY_H_
 
-#include <algorithm>
-#include <queue>
-#include <vector>
-#include <stxxl.h>
-#include <cstdlib>
-
-#include <boost/foreach.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/shared_ptr.hpp>
-
-
 #include "../typedefs.h"
 #include "../DataStructures/DeallocatingVector.h"
 #include "../DataStructures/DynamicGraph.h"
 #include "../Extractor/ExtractorStructs.h"
 #include "../DataStructures/HashTable.h"
 #include "../DataStructures/ImportEdge.h"
+#include "../DataStructures/MercatorUtil.h"
 #include "../DataStructures/QueryEdge.h"
 #include "../DataStructures/Percent.h"
 #include "../DataStructures/TurnInstructions.h"
 #include "../Util/BaseConfiguration.h"
+#include "../Util/LuaUtil.h"
+
+#include <stxxl.h>
+
+#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
+
+#include <cstdlib>
+
+#include <algorithm>
+#include <queue>
+#include <vector>
+
+class EdgeBasedGraphFactory : boost::noncopyable {
+public:
+    struct EdgeBasedNode {
+        bool operator<(const EdgeBasedNode & other) const {
+            return other.id < id;
+        }
+
+        bool operator==(const EdgeBasedNode & other) const {
+            return id == other.id;
+        }
+
+        inline _Coordinate Centroid() const {
+            _Coordinate centroid;
+            //The coordinates of the midpoint are given by:
+            //x = (x1 + x2) /2 and y = (y1 + y2) /2.
+            centroid.lon = (std::min(lon1, lon2) + std::max(lon1, lon2))/2;
+            centroid.lat = (std::min(lat1, lat2) + std::max(lat1, lat2))/2;
+            return centroid;
+        }
+
+        inline bool isIgnored() const {
+            return ignoreInGrid;
+        }
+        NodeID id;
+        int lat1;
+        int lat2;
+        int lon1;
+        int lon2:31;
+        bool belongsToTinyComponent:1;
+        NodeID nameID;
+        unsigned weight:31;
+        bool ignoreInGrid:1;
+    };
+
+    struct SpeedProfileProperties{
+        SpeedProfileProperties()  : trafficSignalPenalty(0), uTurnPenalty(0), has_turn_penalty_function(false) {}
+        int trafficSignalPenalty;
+        int uTurnPenalty;
+        bool has_turn_penalty_function;
+    } speedProfile;
 
-class EdgeBasedGraphFactory {
 private:
     struct _NodeBasedEdgeData {
         int distance;
         unsigned edgeBasedNodeID;
-        unsigned nameID:31;
+        unsigned nameID;
+        short type;
+        bool isAccessRestricted:1;
         bool shortcut:1;
         bool forward:1;
         bool backward:1;
         bool roundabout:1;
         bool ignoreInGrid:1;
-        short type;
-        bool isAccessRestricted;
+        bool contraFlow:1;
     };
 
     struct _EdgeBasedEdgeData {
@@ -76,35 +122,10 @@ private:
     typedef _NodeBasedDynamicGraph::InputEdge _NodeBasedEdge;
     std::vector<NodeInfo>               inputNodeInfoList;
     unsigned numberOfTurnRestrictions;
-public:
-    struct EdgeBasedNode {
-        bool operator<(const EdgeBasedNode & other) const {
-            return other.id < id;
-        }
-        bool operator==(const EdgeBasedNode & other) const {
-            return id == other.id;
-        }
-        NodeID id;
-        int lat1;
-        int lat2;
-        int lon1;
-        int lon2:31;
-        bool belongsToTinyComponent:1;
-        NodeID nameID;
-        unsigned weight:31;
-        bool ignoreInGrid:1;
-    };
 
-
-    struct SpeedProfileProperties{
-        SpeedProfileProperties()  : trafficSignalPenalty(0), uTurnPenalty(0) {}
-        int trafficSignalPenalty;
-        int uTurnPenalty;
-    } speedProfile;
-private:
     boost::shared_ptr<_NodeBasedDynamicGraph>   _nodeBasedGraph;
-    boost::unordered_map<NodeID, bool>          _barrierNodes;
-    boost::unordered_map<NodeID, bool>          _trafficLights;
+    boost::unordered_set<NodeID>          _barrierNodes;
+    boost::unordered_set<NodeID>          _trafficLights;
 
     typedef std::pair<NodeID, NodeID> RestrictionSource;
     typedef std::pair<NodeID, bool>   RestrictionTarget;
@@ -113,10 +134,8 @@ private:
     std::vector<EmanatingRestrictionsVector> _restrictionBucketVector;
     RestrictionMap _restrictionMap;
 
-
     DeallocatingVector<EdgeBasedEdge>   edgeBasedEdges;
-    DeallocatingVector<EdgeBasedNode>   edgeBasedNodes;
-    std::vector<OriginalEdgeData>       originalEdgeData;
+    std::vector<EdgeBasedNode>   edgeBasedNodes;
 
     NodeID CheckForEmanatingIsOnlyTurn(const NodeID u, const NodeID v) const;
     bool CheckIfTurnIsRestricted(const NodeID u, const NodeID v, const NodeID w) const;
@@ -127,18 +146,16 @@ private:
             bool belongsToTinyComponent);
     template<class CoordinateT>
     double GetAngleBetweenTwoEdges(const CoordinateT& A, const CoordinateT& C, const CoordinateT& B) const;
-//    SRTMLookup srtmLookup;
-
 
 public:
     template< class InputEdgeT >
     explicit EdgeBasedGraphFactory(int nodes, std::vector<InputEdgeT> & inputEdges, std::vector<NodeID> & _bollardNodes, std::vector<NodeID> & trafficLights, std::vector<_Restriction> & inputRestrictions, std::vector<NodeInfo> & nI, SpeedProfileProperties speedProfile);
 
-    void Run(const char * originalEdgeDataFilename);
+    void Run(const char * originalEdgeDataFilename, lua_State *myLuaState);
     void GetEdgeBasedEdges( DeallocatingVector< EdgeBasedEdge >& edges );
-    void GetEdgeBasedNodes( DeallocatingVector< EdgeBasedNode> & nodes);
+    void GetEdgeBasedNodes( std::vector< EdgeBasedNode> & nodes);
     void GetOriginalEdgeData( std::vector< OriginalEdgeData> & originalEdgeData);
-    TurnInstruction AnalyzeTurn(const NodeID u, const NodeID v, const NodeID w) const;
+    TurnInstruction AnalyzeTurn(const NodeID u, const NodeID v, const NodeID w, unsigned& penalty, lua_State *myLuaState) const;
     unsigned GetNumberOfNodes() const;
 };
 

Contractor/TemporaryStorage.h

@@ -33,8 +33,8 @@
 
 //This is one big workaround for latest boost renaming woes.
 
-#ifndef BOOST_FILESYSTEM_VERSION
-#warning Boost Installation with Filesystem3 (>=1.44) is required, activating workaround
+#if BOOST_FILESYSTEM_VERSION < 3
+#warning Boost Installation with Filesystem3 missing, activating workaround
 #include <cstdio>
 namespace boost {
 namespace filesystem {
@@ -54,8 +54,9 @@ inline path unique_path(const path&) {
 
 #endif
 
+#ifndef BOOST_FILESYSTEM_VERSION
 #define BOOST_FILESYSTEM_VERSION 3
-
+#endif
 /**
  * This class implements a singleton file storage for temporary data.
  * temporary slots can be accessed by other objects through an int
@@ -89,8 +90,6 @@ private:
     }
     void abort(boost::filesystem::filesystem_error& e);
 
-    ;
-
     struct StreamData {
         bool writeMode;
         boost::filesystem::path pathToTemporaryFile;

DataStructures/BinaryHeap.h

@@ -75,10 +75,13 @@ template< typename NodeID, typename Key >
 class UnorderedMapStorage {
 public:
 
-	UnorderedMapStorage( size_t ) {  }
+	UnorderedMapStorage( size_t ) {
+		//hash table gets 1000 Buckets
+		nodes.rehash(1000);
+	}
 
-    Key &operator[]( NodeID node ) {
-        return nodes[node];
+    Key &operator[]( const NodeID node ) {
+    	return nodes[node];
     }
 
     void Clear() {

DataStructures/Coordinate.h

@@ -21,7 +21,10 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #ifndef COORDINATE_H_
 #define COORDINATE_H_
 
+#include <cassert>
+#include <cmath>
 #include <climits>
+
 #include <iostream>
 
 struct _Coordinate {
@@ -102,5 +105,4 @@ inline double ApproximateDistanceByEuclid(const _Coordinate &c1, const _Coordina
     return d;
 }
 
-
 #endif /* COORDINATE_H_ */

DataStructures/DeallocatingVector.h

@@ -22,7 +22,6 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #define DEALLOCATINGVECTOR_H_
 
 #include <cassert>
-#include <cstdlib>
 #include <vector>
 
 #if __cplusplus > 199711L
@@ -32,7 +31,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #endif
 
 
-template<typename ElementT, size_t bucketSizeC = 10485760/sizeof(ElementT), bool DeallocateC = false>
+template<typename ElementT, std::size_t bucketSizeC = 8388608/sizeof(ElementT), bool DeallocateC = false>
 class DeallocatingVectorIterator : public std::iterator<std::random_access_iterator_tag, ElementT> {
 protected:
 
@@ -42,12 +41,12 @@ protected:
         DeallocatingVectorIteratorState();
     public:
         explicit DeallocatingVectorIteratorState(const DeallocatingVectorIteratorState &r) : mData(r.mData), mIndex(r.mIndex), mBucketList(r.mBucketList) {}
-        //explicit DeallocatingVectorIteratorState(const ElementT * ptr, const size_t idx, const std::vector<ElementT *> & input_list) : mData(ptr), mIndex(idx), mBucketList(input_list) {}
-        explicit DeallocatingVectorIteratorState(const size_t idx, std::vector<ElementT *> & input_list) : mData(DEALLOCATION_VECTOR_NULL_PTR), mIndex(idx), mBucketList(input_list) {
+        //explicit DeallocatingVectorIteratorState(const ElementT * ptr, const std::size_t idx, const std::vector<ElementT *> & input_list) : mData(ptr), mIndex(idx), mBucketList(input_list) {}
+        explicit DeallocatingVectorIteratorState(const std::size_t idx, std::vector<ElementT *> & input_list) : mData(DEALLOCATION_VECTOR_NULL_PTR), mIndex(idx), mBucketList(input_list) {
             setPointerForIndex();
         }
         ElementT * mData;
-        size_t mIndex;
+        std::size_t mIndex;
         std::vector<ElementT *> & mBucketList;
 
         inline void setPointerForIndex() {
@@ -55,8 +54,8 @@ protected:
                 mData = DEALLOCATION_VECTOR_NULL_PTR;
                 return;
             }
-            size_t _bucket = mIndex/bucketSizeC;
-            size_t _index = mIndex%bucketSizeC;
+            std::size_t _bucket = mIndex/bucketSizeC;
+            std::size_t _index = mIndex%bucketSizeC;
             mData = &(mBucketList[_bucket][_index]);
 
             if(DeallocateC) {
@@ -104,8 +103,8 @@ public:
     template<typename T2>
     DeallocatingVectorIterator(const DeallocatingVectorIterator<T2> & r) : mState(r.mState) {}
 
-    DeallocatingVectorIterator(size_t idx, std::vector<ElementT *> & input_list) : mState(idx, input_list) {}
-    //DeallocatingVectorIterator(size_t idx, const std::vector<ElementT *> & input_list) : mState(idx, input_list) {}
+    DeallocatingVectorIterator(std::size_t idx, std::vector<ElementT *> & input_list) : mState(idx, input_list) {}
+    //DeallocatingVectorIterator(std::size_t idx, const std::vector<ElementT *> & input_list) : mState(idx, input_list) {}
     DeallocatingVectorIterator(const DeallocatingVectorIteratorState & r) : mState(r) {}
 
     template<typename T2>
@@ -185,10 +184,10 @@ public:
     }
 };
 
-template<typename ElementT, size_t bucketSizeC = 10485760/sizeof(ElementT) >
+template<typename ElementT, std::size_t bucketSizeC = 8388608/sizeof(ElementT) >
 class DeallocatingVector {
 private:
-    size_t mCurrentSize;
+    std::size_t mCurrentSize;
     std::vector<ElementT *> mBucketList;
 
 public:
@@ -227,21 +226,21 @@ public:
     }
 
     inline void push_back(const ElementT & element) {
-        size_t _capacity = capacity();
+        std::size_t _capacity = capacity();
         if(mCurrentSize == _capacity) {
             mBucketList.push_back(new ElementT[bucketSizeC]);
         }
 
-        size_t _index = size()%bucketSizeC;
+        std::size_t _index = size()%bucketSizeC;
         mBucketList.back()[_index] = element;
         ++mCurrentSize;
     }
 
-    inline void reserve(const size_t) const {
+    inline void reserve(const std::size_t) const {
         //don't do anything
     }
 
-    inline void resize(const size_t new_size) {
+    inline void resize(const std::size_t new_size) {
         if(new_size > mCurrentSize) {
             while(capacity() < new_size) {
                 mBucketList.push_back(new ElementT[bucketSizeC]);
@@ -249,7 +248,7 @@ public:
             mCurrentSize = new_size;
         }
         if(new_size < mCurrentSize) {
-            size_t number_of_necessary_buckets = 1+(new_size / bucketSizeC);
+            std::size_t number_of_necessary_buckets = 1+(new_size / bucketSizeC);
 
             for(unsigned i = number_of_necessary_buckets; i < mBucketList.size(); ++i) {
                 delete[] mBucketList[i];
@@ -259,16 +258,16 @@ public:
         }
     }
 
-    inline size_t size() const {
+    inline std::size_t size() const {
         return mCurrentSize;
     }
 
-    inline size_t capacity() const {
+    inline std::size_t capacity() const {
         return mBucketList.size() * bucketSizeC;
     }
 
     inline iterator begin() {
-        return iterator(static_cast<size_t>(0), mBucketList);
+        return iterator(static_cast<std::size_t>(0), mBucketList);
     }
 
     inline iterator end() {
@@ -276,7 +275,7 @@ public:
     }
 
     inline deallocation_iterator dbegin() {
-        return deallocation_iterator(static_cast<size_t>(0), mBucketList);
+        return deallocation_iterator(static_cast<std::size_t>(0), mBucketList);
     }
 
     inline deallocation_iterator dend() {
@@ -284,24 +283,36 @@ public:
     }
 
     inline const_iterator begin() const {
-        return const_iterator(static_cast<size_t>(0), mBucketList);
+        return const_iterator(static_cast<std::size_t>(0), mBucketList);
     }
 
     inline const_iterator end() const {
         return const_iterator(size(), mBucketList);
     }
 
-    inline ElementT & operator[](const size_t index) {
-        size_t _bucket = index / bucketSizeC;
-        size_t _index = index % bucketSizeC;
+    inline ElementT & operator[](const std::size_t index) {
+        std::size_t _bucket = index / bucketSizeC;
+        std::size_t _index = index % bucketSizeC;
         return (mBucketList[_bucket][_index]);
     }
 
-    const inline ElementT & operator[](const size_t index) const {
-        size_t _bucket = index / bucketSizeC;
-        size_t _index = index % bucketSizeC;
+    const inline ElementT & operator[](const std::size_t index) const {
+        std::size_t _bucket = index / bucketSizeC;
+        std::size_t _index = index % bucketSizeC;
         return (mBucketList[_bucket][_index]);
     }
+
+    inline ElementT & back() {
+        std::size_t _bucket = mCurrentSize / bucketSizeC;
+    	std::size_t _index = mCurrentSize % bucketSizeC;
+    	return (mBucketList[_bucket][_index]);
+    }
+
+    const inline ElementT & back() const {
+        std::size_t _bucket = mCurrentSize / bucketSizeC;
+        std::size_t _index = mCurrentSize % bucketSizeC;
+    	return (mBucketList[_bucket][_index]);
+    }
 };
 
 #endif /* DEALLOCATINGVECTOR_H_ */

DataStructures/DynamicGraph.h

@@ -21,18 +21,21 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #ifndef DYNAMICGRAPH_H_INCLUDED
 #define DYNAMICGRAPH_H_INCLUDED
 
-#include <vector>
+#include "../DataStructures/DeallocatingVector.h"
+
+#include <boost/assert.hpp>
+#include <boost/integer.hpp>
+
 #include <algorithm>
 #include <limits>
-
-#include "../DataStructures/DeallocatingVector.h"
+#include <vector>
 
 template< typename EdgeDataT>
 class DynamicGraph {
     public:
         typedef EdgeDataT EdgeData;
-        typedef unsigned NodeIterator;
-        typedef unsigned EdgeIterator;
+        typedef uint32_t NodeIterator;
+        typedef uint32_t EdgeIterator;
 
         class InputEdge {
             public:
@@ -47,20 +50,20 @@ class DynamicGraph {
         };
 
         //Constructs an empty graph with a given number of nodes.
-        DynamicGraph( int nodes ) : m_numNodes(nodes), m_numEdges(0) {
+        DynamicGraph( int32_t nodes ) : m_numNodes(nodes), m_numEdges(0) {
             m_nodes.reserve( m_numNodes );
             m_nodes.resize( m_numNodes );
 
             m_edges.reserve( m_numNodes * 1.1 );
             m_edges.resize( m_numNodes );
         }
+
         template<class ContainerT>
-        DynamicGraph( const int nodes, const ContainerT &graph )
-        {
+        DynamicGraph( const int32_t nodes, const ContainerT &graph ) {
             m_numNodes = nodes;
             m_numEdges = ( EdgeIterator ) graph.size();
-            m_nodes.reserve( m_numNodes );
-            m_nodes.resize( m_numNodes );
+            m_nodes.reserve( m_numNodes +1);
+            m_nodes.resize( m_numNodes +1);
             EdgeIterator edge = 0;
             EdgeIterator position = 0;
             for ( NodeIterator node = 0; node < m_numNodes; ++node ) {
@@ -72,6 +75,7 @@ class DynamicGraph {
                 m_nodes[node].edges = edge - lastEdge;
                 position += m_nodes[node].edges;
             }
+            m_nodes.back().firstEdge = position;
             m_edges.reserve( position * 1.1 );
             m_edges.resize( position );
             edge = 0;
@@ -79,7 +83,10 @@ class DynamicGraph {
                 for ( EdgeIterator i = m_nodes[node].firstEdge, e = m_nodes[node].firstEdge + m_nodes[node].edges; i != e; ++i ) {
                     m_edges[i].target = graph[edge].target;
                     m_edges[i].data = graph[edge].data;
-                    GUARANTEE(graph[edge].data.distance > 0, "edge: " << edge << "(" << graph[edge].source << "," << graph[edge].target << ")=" << graph[edge].data.distance);
+                    BOOST_ASSERT_MSG(
+                        graph[edge].data.distance > 0,
+                        "edge distance invalid"
+                    );
                     ++edge;
                 }
             }
@@ -87,50 +94,40 @@ class DynamicGraph {
 
         ~DynamicGraph(){ }
 
-        unsigned GetNumberOfNodes() const
-        {
+        uint32_t GetNumberOfNodes() const {
             return m_numNodes;
         }
 
-        unsigned GetNumberOfEdges() const
-        {
+        uint32_t GetNumberOfEdges() const {
             return m_numEdges;
         }
 
-        unsigned GetOutDegree( const NodeIterator &n ) const
-        {
+        uint32_t GetOutDegree( const NodeIterator n ) const {
             return m_nodes[n].edges;
         }
 
-        NodeIterator GetTarget( const EdgeIterator &e ) const
-        {
+        NodeIterator GetTarget( const EdgeIterator e ) const {
             return NodeIterator( m_edges[e].target );
         }
 
-        EdgeDataT &GetEdgeData( const EdgeIterator &e )
-        {
+        EdgeDataT &GetEdgeData( const EdgeIterator e ) {
             return m_edges[e].data;
         }
 
-        const EdgeDataT &GetEdgeData( const EdgeIterator &e ) const
-        {
+        const EdgeDataT &GetEdgeData( const EdgeIterator e ) const {
             return m_edges[e].data;
         }
 
-        EdgeIterator BeginEdges( const NodeIterator &n ) const
-        {
-            //assert( EndEdges( n ) - EdgeIterator( _nodes[n].firstEdge ) <= 100 );
+        EdgeIterator BeginEdges( const NodeIterator n ) const {
             return EdgeIterator( m_nodes[n].firstEdge );
         }
 
-        EdgeIterator EndEdges( const NodeIterator &n ) const
-        {
+        EdgeIterator EndEdges( const NodeIterator n ) const {
             return EdgeIterator( m_nodes[n].firstEdge + m_nodes[n].edges );
         }
 
         //adds an edge. Invalidates edge iterators for the source node
-        EdgeIterator InsertEdge( const NodeIterator &from, const NodeIterator &to, const EdgeDataT &data )
-        {
+        EdgeIterator InsertEdge( const NodeIterator from, const NodeIterator to, const EdgeDataT &data ) {
             Node &node = m_nodes[from];
             EdgeIterator newFirstEdge = node.edges + node.firstEdge;
             if ( newFirstEdge >= m_edges.size() || !isDummy( newFirstEdge ) ) {
@@ -139,7 +136,7 @@ class DynamicGraph {
                     m_edges[node.firstEdge] = m_edges[node.firstEdge + node.edges];
                 } else {
                     EdgeIterator newFirstEdge = ( EdgeIterator ) m_edges.size();
-                    unsigned newSize = node.edges * 1.1 + 2;
+                    uint32_t newSize = node.edges * 1.1 + 2;
                     EdgeIterator requiredCapacity = newSize + m_edges.size();
                     EdgeIterator oldCapacity = m_edges.capacity();
                     if ( requiredCapacity >= oldCapacity ) {
@@ -164,20 +161,19 @@ class DynamicGraph {
         }
 
         //removes an edge. Invalidates edge iterators for the source node
-        void DeleteEdge( const NodeIterator source, const EdgeIterator &e ) {
+        void DeleteEdge( const NodeIterator source, const EdgeIterator e ) {
             Node &node = m_nodes[source];
             --m_numEdges;
             --node.edges;
-            const unsigned last = node.firstEdge + node.edges;
+            const uint32_t last = node.firstEdge + node.edges;
             //swap with last edge
             m_edges[e] = m_edges[last];
             makeDummy( last );
         }
 
         //removes all edges (source,target)
-        int DeleteEdgesTo( const NodeIterator source, const NodeIterator target )
-        {
-            int deleted = 0;
+        int32_t DeleteEdgesTo( const NodeIterator source, const NodeIterator target ) {
+            int32_t deleted = 0;
             for ( EdgeIterator i = BeginEdges( source ), iend = EndEdges( source ); i < iend - deleted; ++i ) {
                 if ( m_edges[i].target == target ) {
                     do {
@@ -196,8 +192,7 @@ class DynamicGraph {
         }
 
         //searches for a specific edge
-        EdgeIterator FindEdge( const NodeIterator &from, const NodeIterator &to ) const
-        {
+        EdgeIterator FindEdge( const NodeIterator from, const NodeIterator to ) const {
             for ( EdgeIterator i = BeginEdges( from ), iend = EndEdges( from ); i != iend; ++i ) {
                 if ( m_edges[i].target == to ) {
                     return i;
@@ -208,13 +203,11 @@ class DynamicGraph {
 
     protected:
 
-        bool isDummy( EdgeIterator edge ) const
-        {
+        bool isDummy( const EdgeIterator edge ) const {
             return m_edges[edge].target == (std::numeric_limits< NodeIterator >::max)();
         }
 
-        void makeDummy( EdgeIterator edge )
-        {
+        void makeDummy( const EdgeIterator edge ) {
             m_edges[edge].target = (std::numeric_limits< NodeIterator >::max)();
         }
 
@@ -222,7 +215,7 @@ class DynamicGraph {
             //index of the first edge
             EdgeIterator firstEdge;
             //amount of edges
-            unsigned edges;
+            uint32_t edges;
         };
 
         struct Edge {
@@ -233,9 +226,8 @@ class DynamicGraph {
         NodeIterator m_numNodes;
         EdgeIterator m_numEdges;
 
-       DeallocatingVector< Node > m_nodes;
-       DeallocatingVector< Edge > m_edges;
-
+        std::vector< Node > m_nodes;
+        DeallocatingVector< Edge > m_edges;
 };
 
 #endif // DYNAMICGRAPH_H_INCLUDED

DataStructures/HilbertValue.h

@@ -0,0 +1,87 @@
+/*
+    open source routing machine
+    Copyright (C) Dennis Luxen, others 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+ */
+
+#ifndef HILBERTVALUE_H_
+#define HILBERTVALUE_H_
+
+#include <boost/integer.hpp>
+#include <boost/noncopyable.hpp>
+
+// computes a 64 bit value that corresponds to the hilbert space filling curve
+
+class HilbertCode : boost::noncopyable {
+public:
+	static uint64_t GetHilbertNumberForCoordinate(
+			const _Coordinate & current_coordinate) {
+		unsigned location[2];
+		location[0] = current_coordinate.lat+( 90*100000);
+		location[1] = current_coordinate.lon+(180*100000);
+
+		TransposeCoordinate(location);
+		const uint64_t result = BitInterleaving(location[0], location[1]);
+		return result;
+	}
+private:
+	static inline uint64_t BitInterleaving(const uint32_t a, const uint32_t b) {
+		uint64_t result = 0;
+		for(int8_t index = 31; index >= 0; --index){
+			result |= (a >> index) & 1;
+			result <<= 1;
+			result |= (b >> index) & 1;
+			if(0 != index){
+				result <<= 1;
+			}
+		}
+		return result;
+	}
+
+	static inline void TransposeCoordinate( uint32_t * X) {
+		uint32_t M = 1 << (32-1), P, Q, t;
+		int i;
+		// Inverse undo
+		for( Q = M; Q > 1; Q >>= 1 ) {
+			P=Q-1;
+			for( i = 0; i < 2; ++i ) {
+				if( X[i] & Q ) {
+					X[0] ^= P; // invert
+				} else {
+					t = (X[0]^X[i]) & P;
+					X[0] ^= t;
+					X[i] ^= t;
+				}
+			} // exchange
+		}
+		// Gray encode
+		for( i = 1; i < 2; ++i ) {
+			X[i] ^= X[i-1];
+		}
+		t=0;
+		for( Q = M; Q > 1; Q >>= 1 ) {
+			if( X[2-1] & Q ) {
+				t ^= Q-1;
+			}
+		} //check if this for loop is wrong
+		for( i = 0; i < 2; ++i ) {
+			X[i] ^= t;
+		}
+	}
+};
+
+#endif /* HILBERTVALUE_H_ */

DataStructures/ImportEdge.h

@@ -16,7 +16,7 @@ You should have received a copy of the GNU Affero General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 or see http://www.gnu.org/licenses/agpl.txt.
-*/
+ */
 
 #ifndef EDGE_H
 #define EDGE_H
@@ -40,12 +40,8 @@ public:
         return (source() < e.source());
     }
 
-    /** Default constructor. target and weight are set to 0.*/
-    NodeBasedEdge() :
-        _source(0), _target(0), _name(0), _weight(0), forward(0), backward(0), _type(0), _roundabout(false), _ignoreInGrid(false), _accessRestricted(false) { assert(false); } //shall not be used.
-
-    explicit NodeBasedEdge(NodeID s, NodeID t, NodeID n, EdgeWeight w, bool f, bool b, short ty, bool ra, bool ig, bool ar) :
-            _source(s), _target(t), _name(n), _weight(w), forward(f), backward(b), _type(ty), _roundabout(ra), _ignoreInGrid(ig), _accessRestricted(ar) { if(ty < 0) {ERR("Type: " << ty);}; }
+    explicit NodeBasedEdge(NodeID s, NodeID t, NodeID n, EdgeWeight w, bool f, bool b, short ty, bool ra, bool ig, bool ar, bool cf) :
+                                            _source(s), _target(t), _name(n), _weight(w), forward(f), backward(b), _type(ty), _roundabout(ra), _ignoreInGrid(ig), _accessRestricted(ar), _contraFlow(cf) { if(ty < 0) {ERR("Type: " << ty);}; }
 
     NodeID target() const {return _target; }
     NodeID source() const {return _source; }
@@ -59,6 +55,7 @@ public:
     bool isRoundabout() const { return _roundabout; }
     bool ignoreInGrid() const { return _ignoreInGrid; }
     bool isAccessRestricted() const { return _accessRestricted; }
+    bool isContraFlow() const { return _contraFlow; }
 
     NodeID _source;
     NodeID _target;
@@ -70,6 +67,13 @@ public:
     bool _roundabout;
     bool _ignoreInGrid;
     bool _accessRestricted;
+    bool _contraFlow;
+
+private:
+    /** Default constructor. target and weight are set to 0.*/
+    NodeBasedEdge() :
+        _source(0), _target(0), _name(0), _weight(0), forward(0), backward(0), _type(0), _roundabout(false), _ignoreInGrid(false), _accessRestricted(false), _contraFlow(false) { assert(false); } //shall not be used.
+
 };
 
 class EdgeBasedEdge {
@@ -91,43 +95,46 @@ public:
 
     template<class EdgeT>
     EdgeBasedEdge(const EdgeT & myEdge ) :
-        _source(myEdge.source),
-        _target(myEdge.target),
-        _edgeID(myEdge.data.via),
-//        _nameID1(myEdge.data.nameID),
-        _weight(myEdge.data.distance),
-        _forward(myEdge.data.forward),
-        _backward(myEdge.data.backward)//,
-//        _turnInstruction(myEdge.data.turnInstruction)
-                { }
+        m_source(myEdge.source),
+        m_target(myEdge.target),
+        m_edgeID(myEdge.data.via),
+        m_weight(myEdge.data.distance),
+        m_forward(myEdge.data.forward),
+        m_backward(myEdge.data.backward)
+    { }
 
     /** Default constructor. target and weight are set to 0.*/
     EdgeBasedEdge() :
-        _source(0), _target(0), _edgeID(0), _weight(0), _forward(false), _backward(false) { }
+        m_source(0),
+        m_target(0),
+        m_edgeID(0),
+        m_weight(0),
+        m_forward(false),
+        m_backward(false)
+    { }
 
-    explicit EdgeBasedEdge(NodeID s, NodeID t, NodeID v, EdgeWeight w, bool f, bool b) :
-            _source(s), _target(t), _edgeID(v), _weight(w), _forward(f), _backward(b){}
+    explicit EdgeBasedEdge(const NodeID s, const NodeID t, const NodeID v, const EdgeWeight w, const bool f, const bool b) :
+        m_source(s),
+        m_target(t),
+        m_edgeID(v),
+        m_weight(w),
+        m_forward(f),
+        m_backward(b)
+    {}
 
-    NodeID target() const {return _target; }
-    NodeID source() const {return _source; }
-    EdgeWeight weight() const {return _weight; }
-    NodeID id() const { return _edgeID; }
-    bool isBackward() const { return _backward; }
-    bool isForward() const { return _forward; }
-
-    NodeID _source;
-    NodeID _target;
-    NodeID _edgeID;
-    EdgeWeight _weight:30;
-    bool _forward:1;
-    bool _backward:1;
-};
-
-struct MinimalEdgeData {
-public:
-    EdgeWeight distance;
-    bool forward;
-    bool backward;
+    NodeID target() const {return m_target; }
+    NodeID source() const {return m_source; }
+    EdgeWeight weight() const {return m_weight; }
+    NodeID id() const { return m_edgeID; }
+    bool isBackward() const { return m_backward; }
+    bool isForward() const { return m_forward; }
+private:
+    NodeID m_source;
+    NodeID m_target;
+    NodeID m_edgeID;
+    EdgeWeight m_weight:30;
+    bool m_forward:1;
+    bool m_backward:1;
 };
 
 typedef NodeBasedEdge ImportEdge;

DataStructures/InputReaderFactory.h

@@ -43,21 +43,21 @@ int readFromBz2Stream( void* pointer, char* buffer, int len ) {
             return read;
         } else if(BZ_STREAM_END == context->error) {
             BZ2_bzReadGetUnused(&context->error, context->bz2, &unusedTmpVoid, &context->nUnused);
-            if(BZ_OK != context->error) { cerr << "Could not BZ2_bzReadGetUnused" << endl; exit(-1);};
+            if(BZ_OK != context->error) {std::cerr << "Could not BZ2_bzReadGetUnused" <<std::endl; exit(-1);};
             unusedTmp = (char*)unusedTmpVoid;
             for(int i=0;i<context->nUnused;i++) {
                 context->unused[i] = unusedTmp[i];
             }
             BZ2_bzReadClose(&context->error, context->bz2);
-            if(BZ_OK != context->error) { cerr << "Could not BZ2_bzReadClose" << endl; exit(-1);};
+            if(BZ_OK != context->error) {std::cerr << "Could not BZ2_bzReadClose" <<std::endl; exit(-1);};
             context->error = BZ_STREAM_END; // set to the stream end for next call to this function
             if(0 == context->nUnused && feof(context->file)) {
                 return read;
             } else {
                 context->bz2 = BZ2_bzReadOpen(&context->error, context->file, 0, 0, context->unused, context->nUnused);
-                if(NULL == context->bz2){ cerr << "Could not open file" << endl; exit(-1);};
+                if(NULL == context->bz2){std::cerr << "Could not open file" <<std::endl; exit(-1);};
             }
-        } else { cerr << "Could not read bz2 file" << endl; exit(-1); }
+        } else { std::cerr << "Could not read bz2 file" << std::endl; exit(-1); }
     }
     return read;
 }
@@ -74,7 +74,7 @@ xmlTextReaderPtr inputReaderFactory( const char* name )
 {
     std::string inputName(name);
 
-    if(inputName.find(".osm.bz2")!=string::npos)
+    if(inputName.find(".osm.bz2")!=std::string::npos)
     {
         BZ2Context* context = new BZ2Context();
         context->error = false;

DataStructures/MercatorUtil.h

@@ -16,20 +16,23 @@ You should have received a copy of the GNU Affero General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 or see http://www.gnu.org/licenses/agpl.txt.
- */
+*/
 
+#ifndef MERCATORUTIL_H_
+#define MERCATORUTIL_H_
 
+#include <cmath>
 
-#ifndef LUAUTIL_H_
-#define LUAUTIL_H_
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
 
-#include <iostream>
-
-template<typename T>
-void LUA_print(T number) {
-  std::cout << "[LUA] " << number << std::endl;
+inline double y2lat(double a) {
+	return 180/M_PI * (2 * atan(exp(a*M_PI/180)) - M_PI/2);
 }
 
+inline double lat2y(double a) {
+	return 180/M_PI * log(tan(M_PI/4+a*(M_PI/180)/2));
+}
 
-
-#endif /* LUAUTIL_H_ */
+#endif /* MERCATORUTIL_H_ */

DataStructures/NNGrid.h

@@ -21,10 +21,12 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #ifndef NNGRID_H_
 #define NNGRID_H_
 
-#include <algorithm>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstring>
+
+#include <algorithm>
 #include <fstream>
 #include <limits>
 #include <vector>
@@ -42,12 +44,12 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include <boost/unordered_map.hpp>
 
 #include "DeallocatingVector.h"
-//#include "ExtractorStructs.h"
 #include "GridEdge.h"
 #include "Percent.h"
 #include "PhantomNodes.h"
-#include "Util.h"
+#include "MercatorUtil.h"
 #include "StaticGraph.h"
+#include "TimingUtil.h"
 #include "../Algorithms/Bresenham.h"
 
 namespace NNGrid{
@@ -58,7 +60,7 @@ template<bool WriteAccess = false>
 class NNGrid {
 public:
     NNGrid() /*: cellCache(500), fileCache(500)*/ {
-        ramIndexTable.resize((1024*1024), ULONG_MAX);
+        ramIndexTable.resize((1024*1024), std::numeric_limits<uint64_t>::max());
     }
 
     NNGrid(const char* rif, const char* _i) {
@@ -66,7 +68,7 @@ public:
             ERR("Not available in Write mode");
         }
         iif = std::string(_i);
-        ramIndexTable.resize((1024*1024), ULONG_MAX);
+        ramIndexTable.resize((1024*1024), std::numeric_limits<uint64_t>::max());
         ramInFile.open(rif, std::ios::in | std::ios::binary);
         if(!ramInFile) { ERR(rif <<  " not found"); }
 
@@ -87,13 +89,13 @@ public:
 
     void OpenIndexFiles() {
         assert(ramInFile.is_open());
-        ramInFile.read(static_cast<char*>(static_cast<void*>(&ramIndexTable[0]) ), sizeof(unsigned long)*1024*1024);
+        ramInFile.read(static_cast<char*>(static_cast<void*>(&ramIndexTable[0]) ), sizeof(uint64_t)*1024*1024);
         ramInFile.close();
     }
 
 #ifndef ROUTED
     template<typename EdgeT>
-    inline void ConstructGrid(DeallocatingVector<EdgeT> & edgeList, char * ramIndexOut, char * fileIndexOut) {
+    inline void ConstructGrid(DeallocatingVector<EdgeT> & edgeList, const char * ramIndexOut, const char * fileIndexOut) {
     	//TODO: Implement this using STXXL-Streams
         Percent p(edgeList.size());
         BOOST_FOREACH(EdgeT & edge, edgeList) {
@@ -106,6 +108,9 @@ public:
             int tlon = edge.lon2;
             AddEdge( _GridEdge( edge.id, edge.nameID, edge.weight, _Coordinate(slat, slon), _Coordinate(tlat, tlon), edge.belongsToTinyComponent ) );
         }
+        if( 0 == entries.size() ) {
+        	ERR("No viable edges for nearest neighbor index. Aborting");
+        }
         double timestamp = get_timestamp();
         //create index file on disk, old one is over written
         indexOutFile.open(fileIndexOut, std::ios::out | std::ios::binary | std::ios::trunc);
@@ -114,8 +119,8 @@ public:
         INFO("finished sorting after " << (get_timestamp() - timestamp) << "s");
         std::vector<GridEntry> entriesInFileWithRAMSameIndex;
         unsigned indexInRamTable = entries.begin()->ramIndex;
-        unsigned long lastPositionInIndexFile = 0;
-        cout << "writing data ..." << flush;
+        uint64_t lastPositionInIndexFile = 0;
+        std::cout << "writing data ..." << std::flush;
         p.reinit(entries.size());
         boost::unordered_map< unsigned, unsigned > cellMap(1024);
         BOOST_FOREACH(GridEntry & gridEntry, entries) {
@@ -143,9 +148,9 @@ public:
         indexOutFile.close();
 
         //Serialize RAM Index
-        ofstream ramFile(ramIndexOut, std::ios::out | std::ios::binary | std::ios::trunc);
+        std::ofstream ramFile(ramIndexOut, std::ios::out | std::ios::binary | std::ios::trunc);
         //write 4 MB of index Table in RAM
-        ramFile.write((char *)&ramIndexTable[0], sizeof(unsigned long)*1024*1024 );
+        ramFile.write((char *)&ramIndexTable[0], sizeof(uint64_t)*1024*1024 );
         //close ram index file
         ramFile.close();
     }
@@ -174,10 +179,10 @@ public:
 //        INFO("looked up " << candidates.size());
         _GridEdge smallestEdge;
         _Coordinate tmp, edgeStartCoord, edgeEndCoord;
-        double dist = numeric_limits<double>::max();
+        double dist = std::numeric_limits<double>::max();
         double r, tmpDist;
 
-        BOOST_FOREACH(_GridEdge candidate, candidates) {
+        BOOST_FOREACH(const _GridEdge & candidate, candidates) {
             if(candidate.belongsToTinyComponent && ignoreTinyComponents)
                 continue;
             r = 0.;
@@ -216,7 +221,7 @@ public:
         //        }
 
 //        INFO("startCoord: " << smallestEdge.startCoord << "; targetCoord: " << smallestEdge.targetCoord << "; newEndpoint: " << resultNode.location);
-        double ratio = (foundNode ? std::min(1., ApproximateDistance(smallestEdge.startCoord, resultNode.location)/ApproximateDistance(smallestEdge.startCoord, smallestEdge.targetCoord)) : 0);
+        const double ratio = (foundNode ? std::min(1., ApproximateDistance(smallestEdge.startCoord, resultNode.location)/ApproximateDistance(smallestEdge.startCoord, smallestEdge.targetCoord)) : 0);
         resultNode.location.lat = round(100000.*(y2lat(static_cast<double>(resultNode.location.lat)/100000.)));
 //        INFO("Length of vector: " << ApproximateDistance(smallestEdge.startCoord, resultNode.location)/ApproximateDistance(smallestEdge.startCoord, smallestEdge.targetCoord));
         //Hack to fix rounding errors and wandering via nodes.
@@ -227,12 +232,13 @@ public:
 
         resultNode.weight1 *= ratio;
         if(INT_MAX != resultNode.weight2) {
-            resultNode.weight2 -= resultNode.weight1;
+            resultNode.weight2 *= (1.-ratio);
         }
         resultNode.ratio = ratio;
-//        INFO("New weight1: " << resultNode.weight1 << ", new weight2: " << resultNode.weight2 << ", ratio: " << ratio);
 //        INFO("start: " << edgeStartCoord << ", end: " << edgeEndCoord);
-//        INFO("selected node: " << resultNode.edgeBasedNode << ", bidirected: " << (resultNode.isBidirected() ? "yes" : "no") <<  "\n--");
+//        INFO("selected node: " << resultNode.edgeBasedNode << ", bidirected: " << (resultNode.isBidirected() ? "yes" : "no"));
+//        INFO("New weight1: " << resultNode.weight1 << ", new weight2: " << resultNode.weight2 << ", ratio: " << ratio);
+ //       INFO("distance to input coordinate: " << ApproximateDistance(location, resultNode.location) <<  "\n--");
 //        double time2 = get_timestamp();
 //        INFO("NN-Lookup in " << 1000*(time2-time1) << "ms");
         return foundNode;
@@ -264,7 +270,7 @@ public:
         }
         _Coordinate tmp;
         double dist = (std::numeric_limits<double>::max)();
-        BOOST_FOREACH(_GridEdge candidate, candidates) {
+        BOOST_FOREACH(const _GridEdge & candidate, candidates) {
             double r = 0.;
             double tmpDist = ComputeDistance(startCoord, candidate.startCoord, candidate.targetCoord, tmp, &r);
             if(tmpDist < dist) {
@@ -310,17 +316,18 @@ private:
         cellMap.insert(insertionVector.begin(), insertionVector.end());
     }
 
-    inline bool DoubleEpsilonCompare(const double d1, const double d2) {
+    inline bool DoubleEpsilonCompare(const double d1, const double d2) const {
         return (std::fabs(d1 - d2) < FLT_EPSILON);
     }
 
-    inline unsigned FillCell(std::vector<GridEntry>& entriesWithSameRAMIndex, const unsigned long fileOffset, boost::unordered_map< unsigned, unsigned > & cellMap ) {
+#ifndef ROUTED
+    inline unsigned FillCell(std::vector<GridEntry>& entriesWithSameRAMIndex, const uint64_t fileOffset, boost::unordered_map< unsigned, unsigned > & cellMap ) {
         std::vector<char> tmpBuffer(32*32*4096,0);
-        unsigned long indexIntoTmpBuffer = 0;
+        uint64_t indexIntoTmpBuffer = 0;
         unsigned numberOfWrittenBytes = 0;
         assert(indexOutFile.is_open());
 
-        std::vector<unsigned long> cellIndex(32*32,ULONG_MAX);
+        std::vector<uint64_t> cellIndex(32*32,std::numeric_limits<uint64_t>::max());
 
         for(unsigned i = 0; i < entriesWithSameRAMIndex.size() -1; ++i) {
             assert(entriesWithSameRAMIndex[i].ramIndex== entriesWithSameRAMIndex[i+1].ramIndex);
@@ -356,8 +363,8 @@ private:
         indexIntoTmpBuffer += FlushEntriesWithSameFileIndexToBuffer(entriesWithSameFileIndex, tmpBuffer, indexIntoTmpBuffer);
 
         assert(entriesWithSameFileIndex.size() == 0);
-        indexOutFile.write(static_cast<char*>(static_cast<void*>(&cellIndex[0])),32*32*sizeof(unsigned long));
-        numberOfWrittenBytes += 32*32*sizeof(unsigned long);
+        indexOutFile.write(static_cast<char*>(static_cast<void*>(&cellIndex[0])),32*32*sizeof(uint64_t));
+        numberOfWrittenBytes += 32*32*sizeof(uint64_t);
 
         //write contents of tmpbuffer to disk
         indexOutFile.write(&tmpBuffer[0], indexIntoTmpBuffer*sizeof(char));
@@ -366,7 +373,7 @@ private:
         return numberOfWrittenBytes;
     }
 
-    inline unsigned FlushEntriesWithSameFileIndexToBuffer( std::vector<GridEntry> &vectorWithSameFileIndex, std::vector<char> & tmpBuffer, const unsigned long index) const {
+    inline unsigned FlushEntriesWithSameFileIndexToBuffer( std::vector<GridEntry> &vectorWithSameFileIndex, std::vector<char> & tmpBuffer, const uint64_t index) const {
         sort( vectorWithSameFileIndex.begin(), vectorWithSameFileIndex.end() );
         vectorWithSameFileIndex.erase(unique(vectorWithSameFileIndex.begin(), vectorWithSameFileIndex.end()), vectorWithSameFileIndex.end());
         const unsigned lengthOfBucket = vectorWithSameFileIndex.size();
@@ -391,11 +398,12 @@ private:
         vectorWithSameFileIndex.clear();
         return counter;
     }
+#endif
 
     inline void GetContentsOfFileBucketEnumerated(const unsigned fileIndex, std::vector<_GridEdge>& result) const {
         unsigned ramIndex = GetRAMIndexFromFileIndex(fileIndex);
-        unsigned long startIndexInFile = ramIndexTable[ramIndex];
-        if(startIndexInFile == ULONG_MAX) {
+        uint64_t startIndexInFile = ramIndexTable[ramIndex];
+        if(startIndexInFile == std::numeric_limits<uint64_t>::max()) {
             return;
         }
         unsigned enumeratedIndex = GetCellIndexFromRAMAndFileIndex(ramIndex, fileIndex);
@@ -409,14 +417,14 @@ private:
         }
 
         //only read the single necessary cell index
-        localStream->seekg(startIndexInFile+(enumeratedIndex*sizeof(unsigned long)));
-        unsigned long fetchedIndex = 0;
-        localStream->read(static_cast<char*>( static_cast<void*>(&fetchedIndex)), sizeof(unsigned long));
+        localStream->seekg(startIndexInFile+(enumeratedIndex*sizeof(uint64_t)));
+        uint64_t fetchedIndex = 0;
+        localStream->read(static_cast<char*>( static_cast<void*>(&fetchedIndex)), sizeof(uint64_t));
 
-        if(fetchedIndex == ULONG_MAX) {
+        if(fetchedIndex == std::numeric_limits<uint64_t>::max()) {
             return;
         }
-        const unsigned long position = fetchedIndex + 32*32*sizeof(unsigned long) ;
+        const uint64_t position = fetchedIndex + 32*32*sizeof(uint64_t) ;
 
         unsigned lengthOfBucket;
         unsigned currentSizeOfResult = result.size();
@@ -428,12 +436,12 @@ private:
 
     inline void GetContentsOfFileBucket(const unsigned fileIndex, std::vector<_GridEdge>& result, boost::unordered_map< unsigned, unsigned> & cellMap) {
         unsigned ramIndex = GetRAMIndexFromFileIndex(fileIndex);
-        unsigned long startIndexInFile = ramIndexTable[ramIndex];
-        if(startIndexInFile == ULONG_MAX) {
+        uint64_t startIndexInFile = ramIndexTable[ramIndex];
+        if(startIndexInFile == std::numeric_limits<uint64_t>::max()) {
             return;
         }
 
-        unsigned long cellIndex[32*32];
+        uint64_t cellIndex[32*32];
 
         cellMap.clear();
         BuildCellIndexToFileIndexMap(ramIndex,  cellMap);
@@ -446,12 +454,12 @@ private:
         }
 
         localStream->seekg(startIndexInFile);
-        localStream->read(static_cast<char*>(static_cast<void*>( cellIndex)), 32*32*sizeof(unsigned long));
+        localStream->read(static_cast<char*>(static_cast<void*>( cellIndex)), 32*32*sizeof(uint64_t));
         assert(cellMap.find(fileIndex) != cellMap.end());
-        if(cellIndex[cellMap[fileIndex]] == ULONG_MAX) {
+        if(cellIndex[cellMap[fileIndex]] == std::numeric_limits<uint64_t>::max()) {
             return;
         }
-        const unsigned long position = cellIndex[cellMap[fileIndex]] + 32*32*sizeof(unsigned long) ;
+        const uint64_t position = cellIndex[cellMap[fileIndex]] + 32*32*sizeof(uint64_t) ;
 
         unsigned lengthOfBucket;
         unsigned currentSizeOfResult = result.size();
@@ -543,7 +551,7 @@ private:
         }
     }
 
-    inline unsigned GetFileIndexForLatLon(const int lt, const int ln) {
+    inline unsigned GetFileIndexForLatLon(const int lt, const int ln) const {
         double lat = lt/100000.;
         double lon = ln/100000.;
 
@@ -574,14 +582,14 @@ private:
         return ramIndex;
     }
 
-    const static unsigned long END_OF_BUCKET_DELIMITER = UINT_MAX;
+    const static uint64_t END_OF_BUCKET_DELIMITER = boost::integer_traits<uint64_t>::const_max;
 
-    std::ofstream indexOutFile;
     std::ifstream ramInFile;
 #ifndef ROUTED
+    std::ofstream indexOutFile;
     stxxl::vector<GridEntry> entries;
 #endif
-    std::vector<unsigned long> ramIndexTable; //8 MB for first level index in RAM
+    std::vector<uint64_t> ramIndexTable; //8 MB for first level index in RAM
     std::string iif;
     //    LRUCache<int,std::vector<unsigned> > cellCache;
     //    LRUCache<int,std::vector<_Edge> > fileCache;

DataStructures/NodeInformationHelpDesk.h

@@ -21,32 +21,49 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #ifndef NODEINFORMATIONHELPDESK_H_
 #define NODEINFORMATIONHELPDESK_H_
 
+#include "NodeCoords.h"
+#include "PhantomNodes.h"
+#include "QueryEdge.h"
+#include "StaticRTree.h"
+#include "../Contractor/EdgeBasedGraphFactory.h"
+#include "../typedefs.h"
+
+#include <boost/assert.hpp>
+#include <boost/noncopyable.hpp>
+
 #include <fstream>
+
 #include <iostream>
 #include <vector>
 
-#include "../typedefs.h"
-#include "../DataStructures/QueryEdge.h"
-#include "NNGrid.h"
-#include "PhantomNodes.h"
-#include "NodeCoords.h"
+typedef EdgeBasedGraphFactory::EdgeBasedNode RTreeLeaf;
 
-class NodeInformationHelpDesk{
+class NodeInformationHelpDesk : boost::noncopyable{
 public:
-    NodeInformationHelpDesk(const char* ramIndexInput, const char* fileIndexInput, const unsigned _numberOfNodes, const unsigned crc) : numberOfNodes(_numberOfNodes), checkSum(crc) {
-        readOnlyGrid = new ReadOnlyGrid(ramIndexInput,fileIndexInput);
-        assert(0 == coordinateVector.size());
+    NodeInformationHelpDesk(
+        const char* ramIndexInput,
+        const char* fileIndexInput,
+        const unsigned number_of_nodes,
+        const unsigned crc) : number_of_nodes(number_of_nodes), checkSum(crc) {
+        read_only_rtree = new StaticRTree<RTreeLeaf>(
+            ramIndexInput,
+            fileIndexInput
+        );
+        BOOST_ASSERT_MSG(
+            0 == coordinateVector.size(),
+            "Coordinate vector not empty"
+        );
     }
 
     //Todo: Shared memory mechanism
-//    NodeInformationHelpDesk(const char* ramIndexInput, const char* fileIndexInput, const unsigned crc) : checkSum(crc) {
-//        readOnlyGrid = new ReadOnlyGrid(ramIndexInput,fileIndexInput);
-//    }
-
 	~NodeInformationHelpDesk() {
-		delete readOnlyGrid;
+		delete read_only_rtree;
 	}
-	void initNNGrid(std::ifstream& nodesInstream, std::ifstream& edgesInStream) {
+
+	void initNNGrid(
+        std::ifstream& nodesInstream,
+        std::ifstream& edgesInStream
+    ) {
 	    DEBUG("Loading node data");
 		NodeInfo b;
 	    while(!nodesInstream.eof()) {
@@ -59,54 +76,70 @@ public:
         DEBUG("Loading edge data");
         unsigned numberOfOrigEdges(0);
         edgesInStream.read((char*)&numberOfOrigEdges, sizeof(unsigned));
-        origEdgeData.resize(numberOfOrigEdges);
-        edgesInStream.read((char*)&(origEdgeData[0]), numberOfOrigEdges*sizeof(OriginalEdgeData));
+        origEdgeData_viaNode.resize(numberOfOrigEdges);
+        origEdgeData_nameID.resize(numberOfOrigEdges);
+        origEdgeData_turnInstruction.resize(numberOfOrigEdges);
+
+        OriginalEdgeData deserialized_originalEdgeData;
+        for(unsigned i = 0; i < numberOfOrigEdges; ++i) {
+        	edgesInStream.read((char*)&(deserialized_originalEdgeData), sizeof(OriginalEdgeData));
+            origEdgeData_viaNode[i] = deserialized_originalEdgeData.viaNode;
+            origEdgeData_nameID[i] 	= deserialized_originalEdgeData.nameID;
+            origEdgeData_turnInstruction[i] = deserialized_originalEdgeData.turnInstruction;
+        }
         edgesInStream.close();
         DEBUG("Loaded " << numberOfOrigEdges << " orig edges");
 	    DEBUG("Opening NN indices");
-	    readOnlyGrid->OpenIndexFiles();
-	}
-
-	void initNNGrid() {
-	    readOnlyGrid->OpenIndexFiles();
 	}
 
 	inline int getLatitudeOfNode(const unsigned id) const {
-	    const NodeID node = origEdgeData.at(id).viaNode;
+	    const NodeID node = origEdgeData_viaNode.at(id);
 	    return coordinateVector.at(node).lat;
 	}
 
 	inline int getLongitudeOfNode(const unsigned id) const {
-        const NodeID node = origEdgeData.at(id).viaNode;
+        const NodeID node = origEdgeData_viaNode.at(id);
 	    return coordinateVector.at(node).lon;
 	}
 
 	inline unsigned getNameIndexFromEdgeID(const unsigned id) const {
-	    return origEdgeData.at(id).nameID;
+	    return origEdgeData_nameID.at(id);
 	}
 
     inline TurnInstruction getTurnInstructionFromEdgeID(const unsigned id) const {
-        return origEdgeData.at(id).turnInstruction;
+        return origEdgeData_turnInstruction.at(id);
     }
 
-    inline NodeID getNumberOfNodes() const { return numberOfNodes; }
-	inline NodeID getNumberOfNodes2() const { return coordinateVector.size(); }
+    inline NodeID getNumberOfNodes() const {
+        return number_of_nodes;
+    }
 
-	inline bool FindNearestNodeCoordForLatLon(const _Coordinate& coord, _Coordinate& result) const {
-		return readOnlyGrid->FindNearestCoordinateOnEdgeInNodeBasedGraph(coord, result);
-	}
+	inline NodeID getNumberOfNodes2() const {
+        return coordinateVector.size();
+    }
 
-	inline bool FindPhantomNodeForCoordinate( const _Coordinate & location, PhantomNode & resultNode, const unsigned zoomLevel) const {
-	    return readOnlyGrid->FindPhantomNodeForCoordinate(location, resultNode, zoomLevel);
-	}
+    inline bool FindNearestNodeCoordForLatLon(
+            const _Coordinate& input_coordinate,
+            _Coordinate& result,
+            const unsigned zoom_level = 18
+    ) const {
+        PhantomNode resulting_phantom_node;
+        bool foundNode = FindPhantomNodeForCoordinate(input_coordinate, resulting_phantom_node, zoom_level);
+        result = resulting_phantom_node.location;
+        return foundNode;
+    }
 
-	inline void FindRoutingStarts(const _Coordinate &start, const _Coordinate &target, PhantomNodes & phantomNodes, const unsigned zoomLevel) const {
-		readOnlyGrid->FindRoutingStarts(start, target, phantomNodes, zoomLevel);
-	}
-
-	inline void FindNearestPointOnEdge(const _Coordinate & input, _Coordinate& output){
-	    readOnlyGrid->FindNearestPointOnEdge(input, output);
-	}
+    inline bool FindPhantomNodeForCoordinate(
+            const _Coordinate & input_coordinate,
+            PhantomNode & resulting_phantom_node,
+            const unsigned zoom_level
+    ) const {
+        return read_only_rtree->FindPhantomNodeForCoordinate(
+                input_coordinate,
+                resulting_phantom_node,
+                zoom_level
+        );
+    }
 
 	inline unsigned GetCheckSum() const {
 	    return checkSum;
@@ -114,10 +147,12 @@ public:
 
 private:
 	std::vector<_Coordinate> coordinateVector;
-    std::vector<OriginalEdgeData> origEdgeData;
+	std::vector<NodeID> origEdgeData_viaNode;
+	std::vector<unsigned> origEdgeData_nameID;
+	std::vector<TurnInstruction> origEdgeData_turnInstruction;
 
-	ReadOnlyGrid * readOnlyGrid;
-	const unsigned numberOfNodes;
+	StaticRTree<EdgeBasedGraphFactory::EdgeBasedNode> * read_only_rtree;
+	const unsigned number_of_nodes;
 	const unsigned checkSum;
 };
 

DataStructures/QueryEdge.h

@@ -41,8 +41,8 @@ struct QueryEdge {
     NodeID target;
     struct EdgeData {
         NodeID id:31;
-        int distance:30;
         bool shortcut:1;
+        int distance:30;
         bool forward:1;
         bool backward:1;
     } data;

DataStructures/SearchEngine.cpp

@@ -0,0 +1,89 @@
+/*
+    open source routing machine
+    Copyright (C) Dennis Luxen, others 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+ */
+
+#include "SearchEngine.h"
+
+SearchEngine::SearchEngine(
+    QueryGraph * g,
+    NodeInformationHelpDesk * nh,
+    std::vector<std::string> & n
+    ) :
+        _queryData(g, nh, n),
+        shortestPath(_queryData),
+        alternativePaths(_queryData)
+    {}
+    SearchEngine::~SearchEngine() {}
+
+void SearchEngine::GetCoordinatesForNodeID(
+    NodeID id,
+    _Coordinate& result
+    ) const {
+    result.lat = _queryData.nodeHelpDesk->getLatitudeOfNode(id);
+    result.lon = _queryData.nodeHelpDesk->getLongitudeOfNode(id);
+}
+
+void SearchEngine::FindPhantomNodeForCoordinate(
+    const _Coordinate & location,
+    PhantomNode & result,
+    const unsigned zoomLevel
+    ) const {
+    _queryData.nodeHelpDesk->FindPhantomNodeForCoordinate(
+        location,
+        result, zoomLevel
+    );
+}
+
+NodeID SearchEngine::GetNameIDForOriginDestinationNodeID(
+    const NodeID s,
+    const NodeID t
+    ) const {
+    if(s == t){
+        return 0;
+    }
+    EdgeID e = _queryData.graph->FindEdge(s, t);
+    if(e == UINT_MAX) {
+        e = _queryData.graph->FindEdge( t, s );
+    }
+    if(UINT_MAX == e) {
+        return 0;
+    }
+    assert(e != UINT_MAX);
+    const QueryEdge::EdgeData ed = _queryData.graph->GetEdgeData(e);
+    return ed.id;
+}
+
+std::string SearchEngine::GetEscapedNameForNameID(const unsigned nameID) const {
+    bool is_name_invalid = (nameID >= _queryData.names.size() || nameID == 0);
+    if (is_name_invalid) {
+        return std::string("");
+    }
+
+    return HTMLEntitize(_queryData.names.at(nameID));
+}
+
+SearchEngineHeapPtr SearchEngineData::forwardHeap;
+SearchEngineHeapPtr SearchEngineData::backwardHeap;
+
+SearchEngineHeapPtr SearchEngineData::forwardHeap2;
+SearchEngineHeapPtr SearchEngineData::backwardHeap2;
+
+SearchEngineHeapPtr SearchEngineData::forwardHeap3;
+SearchEngineHeapPtr SearchEngineData::backwardHeap3;
+

DataStructures/SearchEngine.h

@@ -21,151 +21,48 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #ifndef SEARCHENGINE_H_
 #define SEARCHENGINE_H_
 
-#include <climits>
-#include <deque>
-#include "SimpleStack.h"
-
-#include <boost/thread.hpp>
-
-#include "BinaryHeap.h"
+#include "Coordinate.h"
 #include "NodeInformationHelpDesk.h"
 #include "PhantomNodes.h"
+#include "QueryEdge.h"
+#include "SearchEngineData.h"
 #include "../RoutingAlgorithms/AlternativePathRouting.h"
-#include "../RoutingAlgorithms/BasicRoutingInterface.h"
 #include "../RoutingAlgorithms/ShortestPathRouting.h"
 
 #include "../Util/StringUtil.h"
 #include "../typedefs.h"
 
-struct _HeapData {
-	NodeID parent;
-	_HeapData( NodeID p ) : parent(p) { }
-};
+#include <climits>
+#include <string>
+#include <vector>
 
-typedef boost::thread_specific_ptr<BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> > > SearchEngineHeapPtr;
-
-template<class EdgeData, class GraphT>
-struct SearchEngineData {
-    typedef SearchEngineHeapPtr HeapPtr;
-    typedef GraphT Graph;
-    SearchEngineData(GraphT * g, NodeInformationHelpDesk * nh, std::vector<string> & n) :graph(g), nodeHelpDesk(nh), names(n) {}
-    const GraphT * graph;
-    NodeInformationHelpDesk * nodeHelpDesk;
-    std::vector<string> & names;
-    static HeapPtr forwardHeap;
-    static HeapPtr backwardHeap;
-    static HeapPtr forwardHeap2;
-    static HeapPtr backwardHeap2;
-    static HeapPtr forwardHeap3;
-    static HeapPtr backwardHeap3;
-
-    inline void InitializeOrClearFirstThreadLocalStorage() {
-        if(!forwardHeap.get()) {
-            forwardHeap.reset(new BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> >(nodeHelpDesk->getNumberOfNodes()));
-        }
-        else
-            forwardHeap->Clear();
-
-        if(!backwardHeap.get()) {
-            backwardHeap.reset(new BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> >(nodeHelpDesk->getNumberOfNodes()));
-        }
-        else
-            backwardHeap->Clear();
-    }
-
-    inline void InitializeOrClearSecondThreadLocalStorage() {
-        if(!forwardHeap2.get()) {
-            forwardHeap2.reset(new BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> >(nodeHelpDesk->getNumberOfNodes()));
-        }
-        else
-            forwardHeap2->Clear();
-
-        if(!backwardHeap2.get()) {
-            backwardHeap2.reset(new BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> >(nodeHelpDesk->getNumberOfNodes()));
-        }
-        else
-            backwardHeap2->Clear();
-    }
-
-    inline void InitializeOrClearThirdThreadLocalStorage() {
-        if(!forwardHeap3.get()) {
-            forwardHeap3.reset(new BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> >(nodeHelpDesk->getNumberOfNodes()));
-        }
-        else
-            forwardHeap3->Clear();
-
-        if(!backwardHeap3.get()) {
-            backwardHeap3.reset(new BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> >(nodeHelpDesk->getNumberOfNodes()));
-        }
-        else
-            backwardHeap3->Clear();
-    }
-};
-
-template<class EdgeData, class GraphT>
 class SearchEngine {
 private:
-    typedef SearchEngineData<EdgeData, GraphT> SearchEngineDataT;
-    SearchEngineDataT _queryData;
+    SearchEngineData _queryData;
 
-	inline double absDouble(double input) { if(input < 0) return input*(-1); else return input;}
 public:
-    ShortestPathRouting<SearchEngineDataT> shortestPath;
-    AlternativeRouting<SearchEngineDataT> alternativePaths;
+    ShortestPathRouting<SearchEngineData> shortestPath;
+    AlternativeRouting<SearchEngineData> alternativePaths;
 
-    SearchEngine(GraphT * g, NodeInformationHelpDesk * nh, std::vector<string> & n) :
-	    _queryData(g, nh, n),
-	    shortestPath(_queryData),
-	    alternativePaths(_queryData)
-	{}
-	~SearchEngine() {}
+    SearchEngine(
+        QueryGraph * g, 
+        NodeInformationHelpDesk * nh, 
+        std::vector<std::string> & n
+    );
+	~SearchEngine();
 
-	inline void GetCoordinatesForNodeID(NodeID id, _Coordinate& result) const {
-		result.lat = _queryData.nodeHelpDesk->getLatitudeOfNode(id);
-		result.lon = _queryData.nodeHelpDesk->getLongitudeOfNode(id);
-	}
+	void GetCoordinatesForNodeID(NodeID id, _Coordinate& result) const;
 
-	inline void FindRoutingStarts(const _Coordinate & start, const _Coordinate & target, PhantomNodes & routingStarts) const {
-	    _queryData.nodeHelpDesk->FindRoutingStarts(start, target, routingStarts);
-	}
+    void FindPhantomNodeForCoordinate(
+        const _Coordinate & location, 
+        PhantomNode & result, 
+        unsigned zoomLevel
+    ) const;
 
-	inline void FindPhantomNodeForCoordinate(const _Coordinate & location, PhantomNode & result, unsigned zoomLevel) const {
-	    _queryData.nodeHelpDesk->FindPhantomNodeForCoordinate(location, result, zoomLevel);
-	}
-
-	inline NodeID GetNameIDForOriginDestinationNodeID(const NodeID s, const NodeID t) const {
-		if(s == t)
-			return 0;
-
-		EdgeID e = _queryData.graph->FindEdge(s, t);
-		if(e == UINT_MAX)
-			e = _queryData.graph->FindEdge( t, s );
-		if(UINT_MAX == e) {
-			return 0;
-		}
-		assert(e != UINT_MAX);
-		const EdgeData ed = _queryData.graph->GetEdgeData(e);
-		return ed.via;
-	}
-
-	inline std::string GetEscapedNameForNameID(const unsigned nameID) const {
-	    return ((nameID >= _queryData.names.size() || nameID == 0) ? std::string("") : HTMLEntitize(_queryData.names.at(nameID)));
-	}
-
-	inline std::string GetEscapedNameForEdgeBasedEdgeID(const unsigned edgeID) const {
-		const unsigned nameID = _queryData.graph->GetEdgeData(edgeID).nameID1;
-		return GetEscapedNameForNameID(nameID);
-	}
+    NodeID GetNameIDForOriginDestinationNodeID(
+        const NodeID s, const NodeID t) const;
 
+    std::string GetEscapedNameForNameID(const unsigned nameID) const;
 };
 
-template<class EdgeData, class GraphT> SearchEngineHeapPtr SearchEngineData<EdgeData, GraphT>::forwardHeap;
-template<class EdgeData, class GraphT> SearchEngineHeapPtr SearchEngineData<EdgeData, GraphT>::backwardHeap;
-
-template<class EdgeData, class GraphT> SearchEngineHeapPtr SearchEngineData<EdgeData, GraphT>::forwardHeap2;
-template<class EdgeData, class GraphT> SearchEngineHeapPtr SearchEngineData<EdgeData, GraphT>::backwardHeap2;
-
-template<class EdgeData, class GraphT> SearchEngineHeapPtr SearchEngineData<EdgeData, GraphT>::forwardHeap3;
-template<class EdgeData, class GraphT> SearchEngineHeapPtr SearchEngineData<EdgeData, GraphT>::backwardHeap3;
-
 #endif /* SEARCHENGINE_H_ */

DataStructures/SearchEngineData.cpp

@@ -0,0 +1,60 @@
+/*
+    open source routing machine
+    Copyright (C) Dennis Luxen, others 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+ */
+
+#include "SearchEngineData.h"
+
+void SearchEngineData::InitializeOrClearFirstThreadLocalStorage() {
+    if(!forwardHeap.get()) {
+        forwardHeap.reset(new QueryHeap(nodeHelpDesk->getNumberOfNodes()));
+    } else {
+        forwardHeap->Clear();
+    }
+    if(!backwardHeap.get()) {
+        backwardHeap.reset(new QueryHeap(nodeHelpDesk->getNumberOfNodes()));
+    } else {
+        backwardHeap->Clear();
+    }
+}
+
+void SearchEngineData::InitializeOrClearSecondThreadLocalStorage() {
+    if(!forwardHeap2.get()) {
+        forwardHeap2.reset(new QueryHeap(nodeHelpDesk->getNumberOfNodes()));
+    } else {
+        forwardHeap2->Clear();
+    }
+    if(!backwardHeap2.get()) {
+        backwardHeap2.reset(new QueryHeap(nodeHelpDesk->getNumberOfNodes()));
+     } else {
+        backwardHeap2->Clear();
+    }
+}
+
+void SearchEngineData::InitializeOrClearThirdThreadLocalStorage() {
+    if(!forwardHeap3.get()) {
+        forwardHeap3.reset(new QueryHeap(nodeHelpDesk->getNumberOfNodes()));
+    } else {
+        forwardHeap3->Clear();
+    }
+    if(!backwardHeap3.get()) {
+        backwardHeap3.reset(new QueryHeap(nodeHelpDesk->getNumberOfNodes()));
+    } else {
+        backwardHeap3->Clear();
+    }
+}

DataStructures/SearchEngineData.h

@@ -0,0 +1,60 @@
+/*
+    open source routing machine
+    Copyright (C) Dennis Luxen, others 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+ */
+
+#include "BinaryHeap.h"
+#include "QueryEdge.h"
+#include "NodeInformationHelpDesk.h"
+#include "StaticGraph.h"
+
+#include "../typedefs.h"
+
+#include <boost/thread.hpp>
+
+#include <string>
+#include <vector>
+
+struct _HeapData {
+    NodeID parent;
+    _HeapData( NodeID p ) : parent(p) { }
+};
+typedef StaticGraph<QueryEdge::EdgeData> QueryGraph;
+typedef BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> > QueryHeapType;
+typedef boost::thread_specific_ptr<QueryHeapType> SearchEngineHeapPtr;
+
+struct SearchEngineData {
+    typedef QueryGraph Graph;
+    typedef QueryHeapType QueryHeap;
+    SearchEngineData(QueryGraph * g, NodeInformationHelpDesk * nh, std::vector<std::string> & n) :graph(g), nodeHelpDesk(nh), names(n) {}
+    const QueryGraph * graph;
+    NodeInformationHelpDesk * nodeHelpDesk;
+    std::vector<std::string> & names;
+    static SearchEngineHeapPtr forwardHeap;
+    static SearchEngineHeapPtr backwardHeap;
+    static SearchEngineHeapPtr forwardHeap2;
+    static SearchEngineHeapPtr backwardHeap2;
+    static SearchEngineHeapPtr forwardHeap3;
+    static SearchEngineHeapPtr backwardHeap3;
+
+    void InitializeOrClearFirstThreadLocalStorage();
+
+    void InitializeOrClearSecondThreadLocalStorage();
+
+    void InitializeOrClearThirdThreadLocalStorage();
+};

DataStructures/StaticRTree.h

@@ -0,0 +1,909 @@
+/*
+    open source routing machine
+    Copyright (C) Dennis Luxen, others 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+ */
+
+#ifndef STATICRTREE_H_
+#define STATICRTREE_H_
+
+#include "MercatorUtil.h"
+#include "TimingUtil.h"
+#include "Coordinate.h"
+#include "PhantomNodes.h"
+#include "DeallocatingVector.h"
+#include "HilbertValue.h"
+#include "../typedefs.h"
+
+#include <boost/assert.hpp>
+#include <boost/bind.hpp>
+#include <boost/foreach.hpp>
+#include <boost/algorithm/minmax.hpp>
+#include <boost/algorithm/minmax_element.hpp>
+#include <boost/range/algorithm_ext/erase.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/thread.hpp>
+
+#include <cassert>
+#include <cfloat>
+#include <climits>
+
+#include <algorithm>
+#include <fstream>
+#include <queue>
+#include <vector>
+
+//tuning parameters
+const static uint32_t RTREE_BRANCHING_FACTOR = 50;
+const static uint32_t RTREE_LEAF_NODE_SIZE = 1170;
+
+// Implements a static, i.e. packed, R-tree
+
+static boost::thread_specific_ptr<std::ifstream> thread_local_rtree_stream;
+
+template<class DataT>
+class StaticRTree : boost::noncopyable {
+private:
+    struct RectangleInt2D {
+        RectangleInt2D() :
+            min_lon(INT_MAX),
+            max_lon(INT_MIN),
+            min_lat(INT_MAX),
+            max_lat(INT_MIN) {}
+
+        int32_t min_lon, max_lon;
+        int32_t min_lat, max_lat;
+
+        inline void InitializeMBRectangle(
+                const DataT * objects,
+                const uint32_t element_count
+        ) {
+            for(uint32_t i = 0; i < element_count; ++i) {
+                min_lon = std::min(
+                        min_lon, std::min(objects[i].lon1, objects[i].lon2)
+                );
+                max_lon = std::max(
+                        max_lon, std::max(objects[i].lon1, objects[i].lon2)
+                );
+
+                min_lat = std::min(
+                        min_lat, std::min(objects[i].lat1, objects[i].lat2)
+                );
+                max_lat = std::max(
+                        max_lat, std::max(objects[i].lat1, objects[i].lat2)
+                );
+            }
+        }
+
+        inline void AugmentMBRectangle(const RectangleInt2D & other) {
+            min_lon = std::min(min_lon, other.min_lon);
+            max_lon = std::max(max_lon, other.max_lon);
+            min_lat = std::min(min_lat, other.min_lat);
+            max_lat = std::max(max_lat, other.max_lat);
+        }
+
+        inline _Coordinate Centroid() const {
+            _Coordinate centroid;
+            //The coordinates of the midpoints are given by:
+            //x = (x1 + x2) /2 and y = (y1 + y2) /2.
+            centroid.lon = (min_lon + max_lon)/2;
+            centroid.lat = (min_lat + max_lat)/2;
+            return centroid;
+        }
+
+        inline bool Intersects(const RectangleInt2D & other) const {
+            _Coordinate upper_left (other.max_lat, other.min_lon);
+            _Coordinate upper_right(other.max_lat, other.max_lon);
+            _Coordinate lower_right(other.min_lat, other.max_lon);
+            _Coordinate lower_left (other.min_lat, other.min_lon);
+
+            return (
+                    Contains(upper_left)
+                    || Contains(upper_right)
+                    || Contains(lower_right)
+                    || Contains(lower_left)
+            );
+        }
+
+        inline double GetMinDist(const _Coordinate & location) const {
+            bool is_contained = Contains(location);
+            if (is_contained) {
+                return 0.0;
+            }
+
+            double min_dist = DBL_MAX;
+            min_dist = std::min(
+                    min_dist,
+                    ApproximateDistance(
+                            location.lat,
+                            location.lon,
+                            max_lat,
+                            min_lon
+                    )
+            );
+            min_dist = std::min(
+                    min_dist,
+                    ApproximateDistance(
+                            location.lat,
+                            location.lon,
+                            max_lat,
+                            max_lon
+                    )
+            );
+            min_dist = std::min(
+                    min_dist,
+                    ApproximateDistance(
+                            location.lat,
+                            location.lon,
+                            min_lat,
+                            max_lon
+                    )
+            );
+            min_dist = std::min(
+                    min_dist,
+                    ApproximateDistance(
+                            location.lat,
+                            location.lon,
+                            min_lat,
+                            min_lon
+                    )
+            );
+            return min_dist;
+        }
+
+        inline double GetMinMaxDist(const _Coordinate & location) const {
+            double min_max_dist = DBL_MAX;
+            //Get minmax distance to each of the four sides
+            _Coordinate upper_left (max_lat, min_lon);
+            _Coordinate upper_right(max_lat, max_lon);
+            _Coordinate lower_right(min_lat, max_lon);
+            _Coordinate lower_left (min_lat, min_lon);
+
+            min_max_dist = std::min(
+                    min_max_dist,
+                    std::max(
+                            ApproximateDistance(location, upper_left ),
+                            ApproximateDistance(location, upper_right)
+                    )
+            );
+
+            min_max_dist = std::min(
+                    min_max_dist,
+                    std::max(
+                            ApproximateDistance(location, upper_right),
+                            ApproximateDistance(location, lower_right)
+                    )
+            );
+
+            min_max_dist = std::min(
+                    min_max_dist,
+                    std::max(
+                            ApproximateDistance(location, lower_right),
+                            ApproximateDistance(location, lower_left )
+                    )
+            );
+
+            min_max_dist = std::min(
+                    min_max_dist,
+                    std::max(
+                            ApproximateDistance(location, lower_left ),
+                            ApproximateDistance(location, upper_left )
+                    )
+            );
+            return min_max_dist;
+        }
+
+        inline bool Contains(const _Coordinate & location) const {
+            bool lats_contained =
+                    (location.lat > min_lat) && (location.lat < max_lat);
+            bool lons_contained =
+                    (location.lon > min_lon) && (location.lon < max_lon);
+            return lats_contained && lons_contained;
+        }
+
+        inline friend std::ostream & operator<< ( std::ostream & out, const RectangleInt2D & rect ) {
+            out << rect.min_lat/100000. << "," << rect.min_lon/100000. << " " << rect.max_lat/100000. << "," << rect.max_lon/100000.;
+            return out;
+        }
+    };
+
+    typedef RectangleInt2D RectangleT;
+
+    struct WrappedInputElement {
+        explicit WrappedInputElement(const uint32_t _array_index, const uint64_t _hilbert_value) :
+			        m_array_index(_array_index), m_hilbert_value(_hilbert_value) {}
+        WrappedInputElement() : m_array_index(UINT_MAX), m_hilbert_value(0) {}
+
+        uint32_t m_array_index;
+        uint64_t m_hilbert_value;
+
+        inline bool operator<(const WrappedInputElement & other) const {
+            return m_hilbert_value < other.m_hilbert_value;
+        }
+    };
+
+    struct LeafNode {
+        LeafNode() : object_count(0) {}
+        uint32_t object_count;
+        DataT objects[RTREE_LEAF_NODE_SIZE];
+    };
+
+    struct TreeNode {
+        TreeNode() : child_count(0), child_is_on_disk(false) {}
+        RectangleT minimum_bounding_rectangle;
+        uint32_t child_count:31;
+        bool child_is_on_disk:1;
+        uint32_t children[RTREE_BRANCHING_FACTOR];
+    };
+
+    struct QueryCandidate {
+        explicit QueryCandidate(const uint32_t n_id, const double dist) : node_id(n_id), min_dist(dist)/*, minmax_dist(DBL_MAX)*/ {}
+        QueryCandidate() : node_id(UINT_MAX), min_dist(DBL_MAX)/*, minmax_dist(DBL_MAX)*/ {}
+        uint32_t node_id;
+        double min_dist;
+        //		double minmax_dist;
+        inline bool operator<(const QueryCandidate & other) const {
+            return min_dist < other.min_dist;
+        }
+    };
+
+    std::vector<TreeNode> m_search_tree;
+    uint64_t m_element_count;
+
+    std::string m_leaf_node_filename;
+public:
+    //Construct a pack R-Tree from the input-list with Kamel-Faloutsos algorithm [1]
+    explicit StaticRTree(std::vector<DataT> & input_data_vector, const char * tree_node_filename, const char * leaf_node_filename) :
+    m_leaf_node_filename(leaf_node_filename) {
+        m_element_count = input_data_vector.size();
+        //remove elements that are flagged to be ignored
+//        boost::remove_erase_if(input_data_vector, boost::bind(&DataT::isIgnored, _1 ));
+
+        INFO("constructing r-tree of " << m_element_count << " elements");
+//        INFO("sizeof(LeafNode)=" << sizeof(LeafNode));
+//        INFO("sizeof(TreeNode)=" << sizeof(TreeNode));
+//        INFO("sizeof(WrappedInputElement)=" << sizeof(WrappedInputElement));
+        double time1 = get_timestamp();
+        std::vector<WrappedInputElement> input_wrapper_vector(input_data_vector.size());
+
+        //generate auxiliary vector of hilbert-values
+#pragma omp parallel for schedule(guided)
+        for(uint64_t element_counter = 0; element_counter < m_element_count; ++element_counter) {
+            //INFO("ID: " << input_data_vector[element_counter].id);
+            input_wrapper_vector[element_counter].m_array_index = element_counter;
+            //Get Hilbert-Value for centroid in mercartor projection
+            DataT & current_element = input_data_vector[element_counter];
+            _Coordinate current_centroid = current_element.Centroid();
+            current_centroid.lat = 100000*lat2y(current_centroid.lat/100000.);
+
+            uint64_t current_hilbert_value = HilbertCode::GetHilbertNumberForCoordinate(current_centroid);
+            input_wrapper_vector[element_counter].m_hilbert_value = current_hilbert_value;
+
+        }
+        //INFO("finished wrapper setup");
+
+        //open leaf file
+        std::ofstream leaf_node_file(leaf_node_filename, std::ios::binary);
+        leaf_node_file.write((char*) &m_element_count, sizeof(uint64_t));
+
+        //sort the hilbert-value representatives
+        std::sort(input_wrapper_vector.begin(), input_wrapper_vector.end());
+        //		INFO("finished sorting");
+        std::vector<TreeNode> tree_nodes_in_level;
+
+        //pack M elements into leaf node and write to leaf file
+        uint64_t processed_objects_count = 0;
+        while(processed_objects_count < m_element_count) {
+
+            LeafNode current_leaf;
+            TreeNode current_node;
+            for(uint32_t current_element_index = 0; RTREE_LEAF_NODE_SIZE > current_element_index; ++current_element_index) {
+                if(m_element_count > (processed_objects_count + current_element_index)) {
+                    //					INFO("Checking element " << (processed_objects_count + current_element_index));
+                    uint32_t index_of_next_object = input_wrapper_vector[processed_objects_count + current_element_index].m_array_index;
+                    current_leaf.objects[current_element_index] = input_data_vector[index_of_next_object];
+                    ++current_leaf.object_count;
+                }
+            }
+
+            if(0 == processed_objects_count) {
+                for(uint32_t i = 0; i < current_leaf.object_count; ++i) {
+                    					//INFO("[" << i << "] id: " << current_leaf.objects[i].id << ", weight: " << current_leaf.objects[i].weight << ", " << current_leaf.objects[i].lat1/100000. << "," << current_leaf.objects[i].lon1/100000. << ";" << current_leaf.objects[i].lat2/100000. << "," << current_leaf.objects[i].lon2/100000.);
+                }
+            }
+
+            //generate tree node that resemble the objects in leaf and store it for next level
+            current_node.minimum_bounding_rectangle.InitializeMBRectangle(current_leaf.objects, current_leaf.object_count);
+            current_node.child_is_on_disk = true;
+            current_node.children[0] = tree_nodes_in_level.size();
+            tree_nodes_in_level.push_back(current_node);
+
+            //write leaf_node to leaf node file
+            leaf_node_file.write((char*)&current_leaf, sizeof(current_leaf));
+            processed_objects_count += current_leaf.object_count;
+        }
+
+        //		INFO("wrote " << processed_objects_count << " leaf objects");
+
+        //close leaf file
+        leaf_node_file.close();
+
+        uint32_t processing_level = 0;
+        while(1 < tree_nodes_in_level.size()) {
+            //			INFO("processing " << (uint32_t)tree_nodes_in_level.size() << " tree nodes in level " << processing_level);
+            std::vector<TreeNode> tree_nodes_in_next_level;
+            uint32_t processed_tree_nodes_in_level = 0;
+            while(processed_tree_nodes_in_level < tree_nodes_in_level.size()) {
+                TreeNode parent_node;
+                //pack RTREE_BRANCHING_FACTOR elements into tree_nodes each
+                for(uint32_t current_child_node_index = 0; RTREE_BRANCHING_FACTOR > current_child_node_index; ++current_child_node_index) {
+                    if(processed_tree_nodes_in_level < tree_nodes_in_level.size()) {
+                        TreeNode & current_child_node = tree_nodes_in_level[processed_tree_nodes_in_level];
+                        //add tree node to parent entry
+                        parent_node.children[current_child_node_index] = m_search_tree.size();
+                        m_search_tree.push_back(current_child_node);
+                        //augment MBR of parent
+                        parent_node.minimum_bounding_rectangle.AugmentMBRectangle(current_child_node.minimum_bounding_rectangle);
+                        //increase counters
+                        ++parent_node.child_count;
+                        ++processed_tree_nodes_in_level;
+                    }
+                }
+                tree_nodes_in_next_level.push_back(parent_node);
+                //				INFO("processed: " << processed_tree_nodes_in_level << ", generating " << (uint32_t)tree_nodes_in_next_level.size() << " parents");
+            }
+            tree_nodes_in_level.swap(tree_nodes_in_next_level);
+            ++processing_level;
+        }
+        BOOST_ASSERT_MSG(1 == tree_nodes_in_level.size(), "tree broken, more than one root node");
+        //last remaining entry is the root node;
+        //		INFO("root node has " << (uint32_t)tree_nodes_in_level[0].child_count << " children");
+        //store root node
+        m_search_tree.push_back(tree_nodes_in_level[0]);
+
+        //reverse and renumber tree to have root at index 0
+        std::reverse(m_search_tree.begin(), m_search_tree.end());
+#pragma omp parallel for schedule(guided)
+        for(uint32_t i = 0; i < m_search_tree.size(); ++i) {
+            TreeNode & current_tree_node = m_search_tree[i];
+            for(uint32_t j = 0; j < current_tree_node.child_count; ++j) {
+                const uint32_t old_id = current_tree_node.children[j];
+                const uint32_t new_id = m_search_tree.size() - old_id - 1;
+                current_tree_node.children[j] = new_id;
+            }
+        }
+
+        //open tree file
+        std::ofstream tree_node_file(tree_node_filename, std::ios::binary);
+        uint32_t size_of_tree = m_search_tree.size();
+        BOOST_ASSERT_MSG(0 < size_of_tree, "tree empty");
+        tree_node_file.write((char *)&size_of_tree, sizeof(uint32_t));
+        tree_node_file.write((char *)&m_search_tree[0], sizeof(TreeNode)*size_of_tree);
+        //close tree node file.
+        tree_node_file.close();
+        double time2 = get_timestamp();
+//        INFO("written " << processed_objects_count << " leafs in " << sizeof(LeafNode)*(1+(unsigned)std::ceil(processed_objects_count/RTREE_LEAF_NODE_SIZE) )+sizeof(uint64_t) << " bytes");
+//        INFO("written search tree of " << size_of_tree << " tree nodes in " << sizeof(TreeNode)*size_of_tree+sizeof(uint32_t) << " bytes");
+        INFO("finished r-tree construction in " << (time2-time1) << " seconds");
+
+        //todo: test queries
+/*        INFO("first MBR:" << m_search_tree[0].minimum_bounding_rectangle);
+
+        DataT result;
+        time1 = get_timestamp();
+        bool found_nearest = NearestNeighbor(_Coordinate(50.191085,8.466479), result);
+        time2 = get_timestamp();
+        INFO("found nearest element to (50.191085,8.466479): " << (found_nearest ? "yes" : "no")  << " in " << (time2-time1) << "s at (" << result.lat1/100000. << "," << result.lon1/100000. << " " << result.lat2/100000. << "," << result.lon2/100000. << ")");
+        time1 = get_timestamp();
+        found_nearest = NearestNeighbor(_Coordinate(50.23979, 8.51882), result);
+        time2 = get_timestamp();
+        INFO("found nearest element to (50.23979, 8.51882): " << (found_nearest ? "yes" : "no")  << " in " << (time2-time1) << "s at (" << result.lat1/100000. << "," << result.lon1/100000. << " " << result.lat2/100000. << "," << result.lon2/100000. << ")");
+        time1 = get_timestamp();
+        found_nearest = NearestNeighbor(_Coordinate(49.0316,2.6937), result);
+        time2 = get_timestamp();
+        INFO("found nearest element to (49.0316,2.6937): " << (found_nearest ? "yes" : "no")  << " in " << (time2-time1) << "s at (" << result.lat1/100000. << "," << result.lon1/100000. << " " << result.lat2/100000. << "," << result.lon2/100000. << ")");
+*/
+    }
+
+    //Read-only operation for queries
+    explicit StaticRTree(
+            const char * node_filename,
+            const char * leaf_filename
+    ) : m_leaf_node_filename(leaf_filename) {
+        //INFO("Loading nodes: " << node_filename);
+        //INFO("opening leafs: " << leaf_filename);
+        //open tree node file and load into RAM.
+        std::ifstream tree_node_file(node_filename, std::ios::binary);
+        uint32_t tree_size = 0;
+        tree_node_file.read((char*)&tree_size, sizeof(uint32_t));
+        //INFO("reading " << tree_size << " tree nodes in " << (sizeof(TreeNode)*tree_size) << " bytes");
+        m_search_tree.resize(tree_size);
+        tree_node_file.read((char*)&m_search_tree[0], sizeof(TreeNode)*tree_size);
+        tree_node_file.close();
+
+        //open leaf node file and store thread specific pointer
+        std::ifstream leaf_node_file(leaf_filename, std::ios::binary);
+        leaf_node_file.read((char*)&m_element_count, sizeof(uint64_t));
+        leaf_node_file.close();
+
+        //INFO( tree_size << " nodes in search tree");
+        //INFO( m_element_count << " elements in leafs");
+    }
+/*
+    inline void FindKNearestPhantomNodesForCoordinate(
+        const _Coordinate & location,
+        const unsigned zoom_level,
+        const unsigned candidate_count,
+        std::vector<std::pair<PhantomNode, double> > & result_vector
+    ) const {
+
+        bool ignore_tiny_components = (zoom_level <= 14);
+        DataT nearest_edge;
+
+        uint32_t io_count = 0;
+        uint32_t explored_tree_nodes_count = 0;
+        INFO("searching for coordinate " << input_coordinate);
+        double min_dist = DBL_MAX;
+        double min_max_dist = DBL_MAX;
+        bool found_a_nearest_edge = false;
+
+        _Coordinate nearest, current_start_coordinate, current_end_coordinate;
+
+        //initialize queue with root element
+        std::priority_queue<QueryCandidate> traversal_queue;
+        traversal_queue.push(QueryCandidate(0, m_search_tree[0].minimum_bounding_rectangle.GetMinDist(input_coordinate)));
+        BOOST_ASSERT_MSG(FLT_EPSILON > (0. - traversal_queue.top().min_dist), "Root element in NN Search has min dist != 0.");
+
+        while(!traversal_queue.empty()) {
+            const QueryCandidate current_query_node = traversal_queue.top(); traversal_queue.pop();
+
+            ++explored_tree_nodes_count;
+            bool prune_downward = (current_query_node.min_dist >= min_max_dist);
+            bool prune_upward    = (current_query_node.min_dist >= min_dist);
+            if( !prune_downward && !prune_upward ) { //downward pruning
+                TreeNode & current_tree_node = m_search_tree[current_query_node.node_id];
+                if (current_tree_node.child_is_on_disk) {
+                    LeafNode current_leaf_node;
+                    LoadLeafFromDisk(current_tree_node.children[0], current_leaf_node);
+                    ++io_count;
+                    for(uint32_t i = 0; i < current_leaf_node.object_count; ++i) {
+                        DataT & current_edge = current_leaf_node.objects[i];
+                        if(ignore_tiny_components && current_edge.belongsToTinyComponent) {
+                            continue;
+                        }
+
+                        double current_ratio = 0.;
+                        double current_perpendicular_distance = ComputePerpendicularDistance(
+                                                                                             input_coordinate,
+                                                                                             _Coordinate(current_edge.lat1, current_edge.lon1),
+                                                                                             _Coordinate(current_edge.lat2, current_edge.lon2),
+                                                                                             nearest,
+                                                                                             &current_ratio
+                                                                                             );
+
+                        if(
+                           current_perpendicular_distance < min_dist
+                           && !DoubleEpsilonCompare(
+                                                    current_perpendicular_distance,
+                                                    min_dist
+                                                    )
+                           ) { //found a new minimum
+                            min_dist = current_perpendicular_distance;
+                            result_phantom_node.edgeBasedNode = current_edge.id;
+                            result_phantom_node.nodeBasedEdgeNameID = current_edge.nameID;
+                            result_phantom_node.weight1 = current_edge.weight;
+                            result_phantom_node.weight2 = INT_MAX;
+                            result_phantom_node.location = nearest;
+                            current_start_coordinate.lat = current_edge.lat1;
+                            current_start_coordinate.lon = current_edge.lon1;
+                            current_end_coordinate.lat = current_edge.lat2;
+                            current_end_coordinate.lon = current_edge.lon2;
+                            nearest_edge = current_edge;
+                            found_a_nearest_edge = true;
+                        } else if(
+                                  DoubleEpsilonCompare(current_perpendicular_distance, min_dist) &&
+                                  1 == abs(current_edge.id - result_phantom_node.edgeBasedNode )
+                                  && CoordinatesAreEquivalent(
+                                                              current_start_coordinate,
+                                                              _Coordinate(
+                                                                          current_edge.lat1,
+                                                                          current_edge.lon1
+                                                                          ),
+                                                              _Coordinate(
+                                                                          current_edge.lat2,
+                                                                          current_edge.lon2
+                                                                          ),
+                                                              current_end_coordinate
+                                                              )
+                                  ) {
+                            result_phantom_node.edgeBasedNode = std::min(current_edge.id, result_phantom_node.edgeBasedNode);
+                            result_phantom_node.weight2 = current_edge.weight;
+                        }
+                    }
+                } else {
+                    //traverse children, prune if global mindist is smaller than local one
+                    for (uint32_t i = 0; i < current_tree_node.child_count; ++i) {
+                        const int32_t child_id = current_tree_node.children[i];
+                        TreeNode & child_tree_node = m_search_tree[child_id];
+                        RectangleT & child_rectangle = child_tree_node.minimum_bounding_rectangle;
+                        const double current_min_dist = child_rectangle.GetMinDist(input_coordinate);
+                        const double current_min_max_dist = child_rectangle.GetMinMaxDist(input_coordinate);
+                        if( current_min_max_dist < min_max_dist ) {
+                            min_max_dist = current_min_max_dist;
+                        }
+                        if (current_min_dist > min_max_dist) {
+                            continue;
+                        }
+                        if (current_min_dist > min_dist) { //upward pruning
+                            continue;
+                        }
+                        traversal_queue.push(QueryCandidate(child_id, current_min_dist));
+                    }
+                }
+            }
+        }
+
+        const double ratio = (found_a_nearest_edge ?
+                              std::min(1., ApproximateDistance(_Coordinate(nearest_edge.lat1, nearest_edge.lon1),
+                                                               result_phantom_node.location)/ApproximateDistance(_Coordinate(nearest_edge.lat1, nearest_edge.lon1), _Coordinate(nearest_edge.lat2, nearest_edge.lon2))
+                                       ) : 0
+                              );
+        result_phantom_node.weight1 *= ratio;
+        if(INT_MAX != result_phantom_node.weight2) {
+            result_phantom_node.weight2 *= (1.-ratio);
+        }
+        result_phantom_node.ratio = ratio;
+
+        //Hack to fix rounding errors and wandering via nodes.
+        if(std::abs(input_coordinate.lon - result_phantom_node.location.lon) == 1) {
+            result_phantom_node.location.lon = input_coordinate.lon;
+        }
+        if(std::abs(input_coordinate.lat - result_phantom_node.location.lat) == 1) {
+            result_phantom_node.location.lat = input_coordinate.lat;
+        }
+
+        INFO("mindist: " << min_dist << ", io's: " << io_count << ", nodes: " << explored_tree_nodes_count << ", loc: " << result_phantom_node.location << ", ratio: " << ratio << ", id: " << result_phantom_node.edgeBasedNode);
+        INFO("bidirected: " << (result_phantom_node.isBidirected() ? "yes" : "no") );
+        return found_a_nearest_edge;
+
+    }
+
+  */
+    bool FindPhantomNodeForCoordinate(
+            const _Coordinate & input_coordinate,
+            PhantomNode & result_phantom_node,
+            const unsigned zoom_level
+    ) {
+
+        bool ignore_tiny_components = (zoom_level <= 14);
+        DataT nearest_edge;
+
+        uint32_t io_count = 0;
+        uint32_t explored_tree_nodes_count = 0;
+        //INFO("searching for coordinate " << input_coordinate);
+        double min_dist = DBL_MAX;
+        double min_max_dist = DBL_MAX;
+        bool found_a_nearest_edge = false;
+
+        _Coordinate nearest, current_start_coordinate, current_end_coordinate;
+
+        //initialize queue with root element
+        std::priority_queue<QueryCandidate> traversal_queue;
+        double current_min_dist = m_search_tree[0].minimum_bounding_rectangle.GetMinDist(input_coordinate);
+        traversal_queue.push(
+                             QueryCandidate(0, current_min_dist)
+        );
+
+        BOOST_ASSERT_MSG(
+                         FLT_EPSILON > (0. - traversal_queue.top().min_dist),
+                         "Root element in NN Search has min dist != 0."
+        );
+
+        while(!traversal_queue.empty()) {
+            const QueryCandidate current_query_node = traversal_queue.top(); traversal_queue.pop();
+
+            ++explored_tree_nodes_count;
+            bool prune_downward = (current_query_node.min_dist >= min_max_dist);
+            bool prune_upward    = (current_query_node.min_dist >= min_dist);
+            if( !prune_downward && !prune_upward ) { //downward pruning
+                TreeNode & current_tree_node = m_search_tree[current_query_node.node_id];
+                if (current_tree_node.child_is_on_disk) {
+                    LeafNode current_leaf_node;
+                    LoadLeafFromDisk(current_tree_node.children[0], current_leaf_node);
+                    ++io_count;
+                    //INFO("checking " << current_leaf_node.object_count << " elements");
+                    for(uint32_t i = 0; i < current_leaf_node.object_count; ++i) {
+                        DataT & current_edge = current_leaf_node.objects[i];
+                        if(ignore_tiny_components && current_edge.belongsToTinyComponent) {
+                            continue;
+                        }
+                        if(current_edge.isIgnored()) {
+                            continue;
+                        }
+
+                       double current_ratio = 0.;
+                       double current_perpendicular_distance = ComputePerpendicularDistance(
+                                input_coordinate,
+                                _Coordinate(current_edge.lat1, current_edge.lon1),
+                                _Coordinate(current_edge.lat2, current_edge.lon2),
+                                nearest,
+                                &current_ratio
+                        );
+
+                        //INFO("[" << current_edge.id << "] (" << current_edge.lat1/100000. << "," << current_edge.lon1/100000. << ")==(" << current_edge.lat2/100000. << "," << current_edge.lon2/100000. << ") at distance " << current_perpendicular_distance << " min dist: " << min_dist
+                        //     << ", ratio " << current_ratio
+                        //     );
+
+                        if(
+                                current_perpendicular_distance < min_dist
+                                && !DoubleEpsilonCompare(
+                                        current_perpendicular_distance,
+                                        min_dist
+                                )
+                        ) { //found a new minimum
+                            min_dist = current_perpendicular_distance;
+                            result_phantom_node.edgeBasedNode = current_edge.id;
+                            result_phantom_node.nodeBasedEdgeNameID = current_edge.nameID;
+                            result_phantom_node.weight1 = current_edge.weight;
+                            result_phantom_node.weight2 = INT_MAX;
+                            result_phantom_node.location = nearest;
+                            current_start_coordinate.lat = current_edge.lat1;
+                            current_start_coordinate.lon = current_edge.lon1;
+                            current_end_coordinate.lat = current_edge.lat2;
+                            current_end_coordinate.lon = current_edge.lon2;
+                            nearest_edge = current_edge;
+                            found_a_nearest_edge = true;
+                        } else if(
+                                DoubleEpsilonCompare(current_perpendicular_distance, min_dist) &&
+                                1 == abs(current_edge.id - result_phantom_node.edgeBasedNode )
+                        && CoordinatesAreEquivalent(
+                                current_start_coordinate,
+                                _Coordinate(
+                                        current_edge.lat1,
+                                        current_edge.lon1
+                                ),
+                                _Coordinate(
+                                        current_edge.lat2,
+                                        current_edge.lon2
+                                ),
+                                current_end_coordinate
+                            )
+                        ) {
+                            BOOST_ASSERT_MSG(current_edge.id != result_phantom_node.edgeBasedNode, "IDs not different");
+                            //INFO("found bidirected edge on nodes " << current_edge.id << " and " << result_phantom_node.edgeBasedNode);
+                            result_phantom_node.weight2 = current_edge.weight;
+                            if(current_edge.id < result_phantom_node.edgeBasedNode) {
+                                result_phantom_node.edgeBasedNode = current_edge.id;
+                                std::swap(result_phantom_node.weight1, result_phantom_node.weight2);
+                                std::swap(current_end_coordinate, current_start_coordinate);
+                            //    INFO("case 2");
+                            }
+                            //INFO("w1: " << result_phantom_node.weight1 << ", w2: " << result_phantom_node.weight2);
+                        }
+                    }
+                } else {
+                    //traverse children, prune if global mindist is smaller than local one
+                    for (uint32_t i = 0; i < current_tree_node.child_count; ++i) {
+                        const int32_t child_id = current_tree_node.children[i];
+                        TreeNode & child_tree_node = m_search_tree[child_id];
+                        RectangleT & child_rectangle = child_tree_node.minimum_bounding_rectangle;
+                        const double current_min_dist = child_rectangle.GetMinDist(input_coordinate);
+                        const double current_min_max_dist = child_rectangle.GetMinMaxDist(input_coordinate);
+                        if( current_min_max_dist < min_max_dist ) {
+                            min_max_dist = current_min_max_dist;
+                        }
+                        if (current_min_dist > min_max_dist) {
+                            continue;
+                        }
+                        if (current_min_dist > min_dist) { //upward pruning
+                            continue;
+                        }
+                        traversal_queue.push(QueryCandidate(child_id, current_min_dist));
+                    }
+                }
+            }
+        }
+
+        const double ratio = (found_a_nearest_edge ?
+            std::min(1., ApproximateDistance(current_start_coordinate,
+                result_phantom_node.location)/ApproximateDistance(current_start_coordinate, current_end_coordinate)
+                ) : 0
+            );
+        result_phantom_node.weight1 *= ratio;
+        if(INT_MAX != result_phantom_node.weight2) {
+            result_phantom_node.weight2 *= (1.-ratio);
+        }
+        result_phantom_node.ratio = ratio;
+
+        //Hack to fix rounding errors and wandering via nodes.
+        if(std::abs(input_coordinate.lon - result_phantom_node.location.lon) == 1) {
+            result_phantom_node.location.lon = input_coordinate.lon;
+        }
+        if(std::abs(input_coordinate.lat - result_phantom_node.location.lat) == 1) {
+            result_phantom_node.location.lat = input_coordinate.lat;
+        }
+
+//        INFO("start: (" << nearest_edge.lat1 << "," << nearest_edge.lon1 << "), end: (" << nearest_edge.lat2 << "," << nearest_edge.lon2 << ")" );
+//        INFO("mindist: " << min_dist << ", io's: " << io_count << ", nodes: " << explored_tree_nodes_count << ", loc: " << result_phantom_node.location << ", ratio: " << ratio << ", id: " << result_phantom_node.edgeBasedNode);
+//        INFO("weight1: " << result_phantom_node.weight1 << ", weight2: " << result_phantom_node.weight2);
+//        INFO("bidirected: " << (result_phantom_node.isBidirected() ? "yes" : "no") );
+//        INFO("NameID: " << result_phantom_node.nodeBasedEdgeNameID);
+        return found_a_nearest_edge;
+
+    }
+/*
+    //Nearest-Neighbor query with the Roussopoulos et al. algorithm [2]
+    inline bool NearestNeighbor(const _Coordinate & input_coordinate, DataT & result_element) {
+        uint32_t io_count = 0;
+        uint32_t explored_tree_nodes_count = 0;
+        INFO("searching for coordinate " << input_coordinate);
+        double min_dist = DBL_MAX;
+        double min_max_dist = DBL_MAX;
+        bool found_return_value = false;
+
+        //initialize queue with root element
+        std::priority_queue<QueryCandidate> traversal_queue;
+        traversal_queue.push(QueryCandidate(0, m_search_tree[0].minimum_bounding_rectangle.GetMinDist(input_coordinate)));
+        BOOST_ASSERT_MSG(FLT_EPSILON > (0. - traversal_queue.top().min_dist), "Root element in NN Search has min dist != 0.");
+
+        while(!traversal_queue.empty()) {
+            const QueryCandidate current_query_node = traversal_queue.top(); traversal_queue.pop();
+
+            ++explored_tree_nodes_count;
+
+            //			INFO("popped node " << current_query_node.node_id << " at distance " << current_query_node.min_dist);
+            bool prune_downward = (current_query_node.min_dist >= min_max_dist);
+            bool prune_upward    = (current_query_node.min_dist >= min_dist);
+            //			INFO(" up prune:   " << (prune_upward ? "y" : "n" ));
+            //			INFO(" down prune: " << (prune_downward ? "y" : "n" ));
+            if( prune_downward || prune_upward ) { //downward pruning
+                //				INFO("  pruned node " << current_query_node.node_id << " because " << current_query_node.min_dist << "<" << min_max_dist);
+            } else {
+                TreeNode & current_tree_node = m_search_tree[current_query_node.node_id];
+                if (current_tree_node.child_is_on_disk) {
+                    //					INFO("  Fetching child from disk for id: " << current_query_node.node_id);
+                    LeafNode current_leaf_node;
+                    LoadLeafFromDisk(current_tree_node.children[0], current_leaf_node);
+                    ++io_count;
+                    double ratio = 0.;
+                    _Coordinate nearest;
+                    for(uint32_t i = 0; i < current_leaf_node.object_count; ++i) {
+                        DataT & current_object = current_leaf_node.objects[i];
+                        double current_perpendicular_distance = ComputePerpendicularDistance(
+                                input_coordinate,
+                                _Coordinate(current_object.lat1, current_object.lon1),
+                                _Coordinate(current_object.lat2, current_object.lon2),
+                                nearest,
+                                &ratio
+                        );
+
+                        if(current_perpendicular_distance < min_dist && !DoubleEpsilonCompare(current_perpendicular_distance, min_dist)) { //found a new minimum
+                            min_dist = current_perpendicular_distance;
+                            result_element = current_object;
+                            found_return_value = true;
+                        }
+                    }
+                } else {
+                    //traverse children, prune if global mindist is smaller than local one
+                    //					INFO("  Checking " << current_tree_node.child_count << " children of node " << current_query_node.node_id);
+                    for (uint32_t i = 0; i < current_tree_node.child_count; ++i) {
+                        const int32_t child_id = current_tree_node.children[i];
+                        TreeNode & child_tree_node = m_search_tree[child_id];
+                        RectangleT & child_rectangle = child_tree_node.minimum_bounding_rectangle;
+                        const double current_min_dist = child_rectangle.GetMinDist(input_coordinate);
+                        const double current_min_max_dist = child_rectangle.GetMinMaxDist(input_coordinate);
+                        if( current_min_max_dist < min_max_dist ) {
+                            min_max_dist = current_min_max_dist;
+                        }
+                        if (current_min_dist > min_max_dist) {
+                            continue;
+                        }
+                        if (current_min_dist > min_dist) { //upward pruning
+                            continue;
+                        }
+                        //						INFO("   pushing node " << child_id << " at distance " << current_min_dist);
+                        traversal_queue.push(QueryCandidate(child_id, current_min_dist));
+                    }
+                }
+            }
+        }
+        INFO("mindist: " << min_dist << ", io's: " << io_count << ",  touched nodes: " << explored_tree_nodes_count);
+        return found_return_value;
+    }
+ */
+private:
+    inline void LoadLeafFromDisk(const uint32_t leaf_id, LeafNode& result_node) {
+        if(!thread_local_rtree_stream.get() || !thread_local_rtree_stream->is_open()) {
+            thread_local_rtree_stream.reset(
+                new std::ifstream(
+                        m_leaf_node_filename.c_str(),
+                        std::ios::in | std::ios::binary
+                )
+            );
+        }
+        if(!thread_local_rtree_stream->good()) {
+            thread_local_rtree_stream->clear(std::ios::goodbit);
+            DEBUG("Resetting stale filestream");
+        }
+        uint64_t seek_pos = sizeof(uint64_t) + leaf_id*sizeof(LeafNode);
+        thread_local_rtree_stream->seekg(seek_pos);
+        thread_local_rtree_stream->read((char *)&result_node, sizeof(LeafNode));
+    }
+
+    inline double ComputePerpendicularDistance(
+            const _Coordinate& inputPoint,
+            const _Coordinate& source,
+            const _Coordinate& target,
+            _Coordinate& nearest, double *r) const {
+        const double x = static_cast<double>(inputPoint.lat);
+        const double y = static_cast<double>(inputPoint.lon);
+        const double a = static_cast<double>(source.lat);
+        const double b = static_cast<double>(source.lon);
+        const double c = static_cast<double>(target.lat);
+        const double d = static_cast<double>(target.lon);
+        double p,q,mX,nY;
+        if(fabs(a-c) > FLT_EPSILON){
+            const double m = (d-b)/(c-a); // slope
+            // Projection of (x,y) on line joining (a,b) and (c,d)
+            p = ((x + (m*y)) + (m*m*a - m*b))/(1. + m*m);
+            q = b + m*(p - a);
+        } else {
+            p = c;
+            q = y;
+        }
+        nY = (d*p - c*q)/(a*d - b*c);
+        mX = (p - nY*a)/c;// These values are actually n/m+n and m/m+n , we need
+        // not calculate the explicit values of m an n as we
+        // are just interested in the ratio
+        if(std::isnan(mX)) {
+            *r = (target == inputPoint) ? 1. : 0.;
+        } else {
+            *r = mX;
+        }
+        if(*r<=0.){
+            nearest.lat = source.lat;
+            nearest.lon = source.lon;
+            return ((b - y)*(b - y) + (a - x)*(a - x));
+//            return std::sqrt(((b - y)*(b - y) + (a - x)*(a - x)));
+        } else if(*r >= 1.){
+            nearest.lat = target.lat;
+            nearest.lon = target.lon;
+            return ((d - y)*(d - y) + (c - x)*(c - x));
+//            return std::sqrt(((d - y)*(d - y) + (c - x)*(c - x)));
+        }
+        // point lies in between
+        nearest.lat = p;
+        nearest.lon = q;
+//        return std::sqrt((p-x)*(p-x) + (q-y)*(q-y));
+        return (p-x)*(p-x) + (q-y)*(q-y);
+    }
+
+    inline bool CoordinatesAreEquivalent(const _Coordinate & a, const _Coordinate & b, const _Coordinate & c, const _Coordinate & d) const {
+        return (a == b && c == d) || (a == c && b == d) || (a == d && b == c);
+    }
+
+    inline bool DoubleEpsilonCompare(const double d1, const double d2) const {
+        return (std::fabs(d1 - d2) < FLT_EPSILON);
+    }
+
+};
+
+//[1] "On Packing R-Trees"; I. Kamel, C. Faloutsos; 1993; DOI: 10.1145/170088.170403
+//[2] "Nearest Neighbor Queries", N. Roussopulos et al; 1995; DOI: 10.1145/223784.223794
+
+
+#endif /* STATICRTREE_H_ */

DataStructures/TimingUtil.h

@@ -18,16 +18,12 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 or see http://www.gnu.org/licenses/agpl.txt.
 */
 
-#ifndef TIMEUTIL_H_
-#define TIMEUTIL_H_
+#ifndef TIMINGUTIL_H_
+#define TIMINGUTIL_H_
 
 #include <climits>
-#include <cmath>
 #include <cstdlib>
 
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
 
 #ifdef _WIN32
  #include <sys/timeb.h>
@@ -43,13 +39,6 @@ or see http://www.gnu.org/licenses/agpl.txt.
  #include <sys/time.h>
 #endif
 
-#ifdef _WIN32
- #include <boost/functional/hash.hpp>
-#else
- #include <tr1/functional_hash.h>
-#endif
-#include <boost/thread.hpp>
-
 /** Returns a timestamp (now) in seconds (incl. a fractional part). */
 static inline double get_timestamp() {
     struct timeval tp;
@@ -57,14 +46,5 @@ static inline double get_timestamp() {
     return double(tp.tv_sec) + tp.tv_usec / 1000000.;
 }
 
-static inline double y2lat(double a) { return 180/M_PI * (2 * atan(exp(a*M_PI/180)) - M_PI/2); }
-static inline double lat2y(double a) { return 180/M_PI * log(tan(M_PI/4+a*(M_PI/180)/2)); }
 
-static inline unsigned boost_thread_id_hash(boost::thread::id const& id) {
-	std::stringstream ostr;
-	ostr << id;
-	std::tr1::hash<std::string> h;
-	return h(ostr.str());
-}
-
-#endif /* TIMEUTIL_H_ */
+#endif /* TIMINGUTIL_H_ */

DataStructures/TurnInstructions.h

@@ -21,12 +21,12 @@
 #ifndef TURNINSTRUCTIONS_H_
 #define TURNINSTRUCTIONS_H_
 
-#include <string>
+#include <boost/noncopyable.hpp>
 
 typedef unsigned char TurnInstruction;
 
 //This is a hack until c++0x is available enough to use scoped enums
-struct TurnInstructionsClass {
+struct TurnInstructionsClass : boost::noncopyable {
 
     const static TurnInstruction NoTurn = 0;          //Give no instruction at all
     const static TurnInstruction GoStraight = 1;      //Tell user to go straight!
@@ -44,48 +44,14 @@ struct TurnInstructionsClass {
     const static TurnInstruction StayOnRoundAbout = 13;
     const static TurnInstruction StartAtEndOfStreet = 14;
     const static TurnInstruction ReachedYourDestination = 15;
+    const static TurnInstruction EnterAgainstAllowedDirection = 16;
+    const static TurnInstruction LeaveAgainstAllowedDirection = 17;
 
     const static TurnInstruction AccessRestrictionFlag = 128;
     const static TurnInstruction InverseAccessRestrictionFlag = 0x7f; // ~128 does not work without a warning.
 
     const static int AccessRestrictionPenalty = 1 << 15; //unrelated to the bit set in the restriction flag
 
-//    std::string TurnStrings[16];
-//    std::string Ordinals[12];
-
-    //This is a hack until c++0x is available enough to use initializer lists.
-//    TurnInstructionsClass(){
-//        TurnStrings [0] = "";
-//        TurnStrings [1] = "Continue";
-//        TurnStrings [2] = "Turn slight right";
-//        TurnStrings [3] = "Turn right";
-//        TurnStrings [4] = "Turn sharp right";
-//        TurnStrings [5] = "U-Turn";
-//        TurnStrings [6] = "Turn sharp left";
-//        TurnStrings [7] = "Turn left";
-//        TurnStrings [8] = "Turn slight left";
-//        TurnStrings [9] = "Reach via point";
-//        TurnStrings[10] = "Head";
-//        TurnStrings[11] = "Enter roundabout";
-//        TurnStrings[12] = "Leave roundabout";
-//        TurnStrings[13] = "Stay on roundabout";
-//        TurnStrings[14] = "Start";
-//        TurnStrings[15] = "You have reached your destination";
-//
-//        Ordinals[0]     = "zeroth";
-//        Ordinals[1]     = "first";
-//        Ordinals[2]     = "second";
-//        Ordinals[3]     = "third";
-//        Ordinals[4]     = "fourth";
-//        Ordinals[5]     = "fifth";
-//        Ordinals[6]     = "sixth";
-//        Ordinals[7]     = "seventh";
-//        Ordinals[8]     = "eighth";
-//        Ordinals[9]     = "nineth";
-//        Ordinals[10]    = "tenth";
-//        Ordinals[11]    = "one of the too many";
-//    };
-
     static inline TurnInstruction GetTurnDirectionOfInstruction( const double angle ) {
         if(angle >= 23 && angle < 67) {
             return TurnSharpRight;

DataStructures/XORFastHash.h

@@ -49,7 +49,7 @@ public:
         table1.resize(2 << 16);
         table2.resize(2 << 16);
         for(unsigned i = 0; i < (2 << 16); ++i) {
-            table1[i] = i; table2[i];
+            table1[i] = i; table2[i] = i;
         }
         std::random_shuffle(table1.begin(), table1.end());
         std::random_shuffle(table2.begin(), table2.end());
@@ -75,8 +75,8 @@ public:
         table3.resize(1 << 8);
         table4.resize(1 << 8);
         for(unsigned i = 0; i < (1 << 8); ++i) {
-            table1[i] = i; table2[i];
-            table3[i] = i; table4[i];
+            table1[i] = i; table2[i] = i;
+            table3[i] = i; table4[i] = i;
         }
         std::random_shuffle(table1.begin(), table1.end());
         std::random_shuffle(table2.begin(), table2.end());

Descriptors/BaseDescriptor.h

@@ -28,8 +28,9 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include <vector>
 
 #include "../typedefs.h"
-#include "../DataStructures/PhantomNodes.h"
 #include "../DataStructures/HashTable.h"
+#include "../DataStructures/PhantomNodes.h"
+#include "../DataStructures/SearchEngine.h"
 #include "../Util/StringUtil.h"
 
 #include "../Plugins/RawRouteData.h"
@@ -42,13 +43,12 @@ struct _DescriptorConfig {
     unsigned short z;
 };
 
-template<class SearchEngineT>
 class BaseDescriptor {
 public:
     BaseDescriptor() { }
     //Maybe someone can explain the pure virtual destructor thing to me (dennis)
     virtual ~BaseDescriptor() { }
-    virtual void Run(http::Reply & reply, const RawRouteData &rawRoute, PhantomNodes &phantomNodes, SearchEngineT &sEngine) = 0;
+    virtual void Run(http::Reply & reply, const RawRouteData &rawRoute, PhantomNodes &phantomNodes, SearchEngine &sEngine) = 0;
     virtual void SetConfig(const _DescriptorConfig & config) = 0;
 };
 

Descriptors/DescriptionFactory.cpp

@@ -82,7 +82,7 @@ void DescriptionFactory::AppendUnencodedPolylineString(std::string &output) {
     pc.printUnencodedString(pathDescription, output);
 }
 
-void DescriptionFactory::Run(const SearchEngineT &sEngine, const unsigned zoomLevel) {
+void DescriptionFactory::Run(const SearchEngine &sEngine, const unsigned zoomLevel) {
 
     if(0 == pathDescription.size())
         return;

Descriptors/DescriptionFactory.h

@@ -27,7 +27,6 @@
 #include "../Algorithms/DouglasPeucker.h"
 #include "../Algorithms/PolylineCompressor.h"
 #include "../DataStructures/Coordinate.h"
-#include "../DataStructures/QueryEdge.h"
 #include "../DataStructures/SearchEngine.h"
 #include "../DataStructures/SegmentInformation.h"
 #include "../DataStructures/TurnInstructions.h"
@@ -40,8 +39,6 @@ class DescriptionFactory {
     PolylineCompressor pc;
     PhantomNode startPhantom, targetPhantom;
 
-    typedef SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> > SearchEngineT;
-
     double DegreeToRadian(const double degree) const;
     double RadianToDegree(const double degree) const;
 public:
@@ -53,13 +50,9 @@ public:
         _RouteSummary() : lengthString("0"), durationString("0"), startName(0), destName(0) {}
         void BuildDurationAndLengthStrings(const double distance, const unsigned time) {
             //compute distance/duration for route summary
-            std::ostringstream s;
-            s << round(distance);
-            lengthString = s.str();
+            intToString(round(distance), lengthString);
             int travelTime = time/10 + 1;
-            s.str("");
-            s << travelTime;
-            durationString = s.str();
+            intToString(travelTime, durationString);
         }
     } summary;
 
@@ -77,7 +70,7 @@ public:
     void SetStartSegment(const PhantomNode & startPhantom);
     void SetEndSegment(const PhantomNode & startPhantom);
     void AppendEncodedPolylineString(std::string & output, bool isEncoded);
-    void Run(const SearchEngineT &sEngine, const unsigned zoomLevel);
+    void Run(const SearchEngine &sEngine, const unsigned zoomLevel);
 };
 
 #endif /* DESCRIPTIONFACTORY_H_ */

Descriptors/GPXDescriptor.h

@@ -24,8 +24,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include <boost/foreach.hpp>
 #include "BaseDescriptor.h"
 
-template<class SearchEngineT>
-class GPXDescriptor : public BaseDescriptor<SearchEngineT>{
+class GPXDescriptor : public BaseDescriptor{
 private:
     _DescriptorConfig config;
     _Coordinate current;
@@ -33,12 +32,13 @@ private:
     std::string tmp;
 public:
     void SetConfig(const _DescriptorConfig& c) { config = c; }
-    void Run(http::Reply & reply, const RawRouteData &rawRoute, PhantomNodes &phantomNodes, SearchEngineT &sEngine) {
+    void Run(http::Reply & reply, const RawRouteData &rawRoute, PhantomNodes &phantomNodes, SearchEngine &sEngine) {
         reply.content += ("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
         reply.content += "<gpx creator=\"OSRM Routing Engine\" version=\"1.1\" xmlns=\"http://www.topografix.com/GPX/1/1\" "
                 "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
                 "xsi:schemaLocation=\"http://www.topografix.com/GPX/1/1 gpx.xsd"
                 "\">";
+        reply.content += "<metadata><copyright author=\"Project OSRM\"><license>Data (c) OpenStreetMap contributors (ODbL)</license></copyright></metadata>";
         reply.content += "<rte>";
         if(rawRoute.lengthOfShortestPath != INT_MAX && rawRoute.computedShortestPath.size()) {
             convertInternalLatLonToString(phantomNodes.startPhantom.location.lat, tmp);
@@ -46,7 +46,7 @@ public:
             convertInternalLatLonToString(phantomNodes.startPhantom.location.lon, tmp);
             reply.content += "lon=\"" + tmp + "\"></rtept>";
 
-            BOOST_FOREACH(_PathData pathData, rawRoute.computedShortestPath) {
+            BOOST_FOREACH(const _PathData & pathData, rawRoute.computedShortestPath) {
                 sEngine.GetCoordinatesForNodeID(pathData.node, current);
 
                 convertInternalLatLonToString(current.lat, tmp);

Descriptors/JSONDescriptor.h

@@ -34,8 +34,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include "../Util/Azimuth.h"
 #include "../Util/StringUtil.h"
 
-template<class SearchEngineT>
-class JSONDescriptor : public BaseDescriptor<SearchEngineT>{
+class JSONDescriptor : public BaseDescriptor{
 private:
     _DescriptorConfig config;
     DescriptionFactory descriptionFactory;
@@ -68,7 +67,7 @@ public:
     JSONDescriptor() : numberOfEnteredRestrictedAreas(0) {}
     void SetConfig(const _DescriptorConfig & c) { config = c; }
 
-    void Run(http::Reply & reply, const RawRouteData &rawRoute, PhantomNodes &phantomNodes, SearchEngineT &sEngine) {
+    void Run(http::Reply & reply, const RawRouteData &rawRoute, PhantomNodes &phantomNodes, SearchEngine &sEngine) {
 
         WriteHeaderToOutput(reply.content);
 
@@ -246,7 +245,7 @@ public:
         reply.content += "}";
     }
 
-    void GetRouteNames(std::vector<Segment> & shortestSegments, std::vector<Segment> & alternativeSegments, SearchEngineT &sEngine, RouteNames & routeNames) {
+    void GetRouteNames(std::vector<Segment> & shortestSegments, std::vector<Segment> & alternativeSegments, const SearchEngine &sEngine, RouteNames & routeNames) {
         /*** extract names for both alternatives ***/
 
         Segment shortestSegment1, shortestSegment2;
@@ -262,23 +261,25 @@ public:
             std::vector<Segment> shortestDifference(shortestSegments.size());
             std::vector<Segment> alternativeDifference(alternativeSegments.size());
             std::set_difference(shortestSegments.begin(), shortestSegments.end(), alternativeSegments.begin(), alternativeSegments.end(), shortestDifference.begin(), boost::bind(&Segment::nameID, _1) < boost::bind(&Segment::nameID, _2) );
-            if(0 < shortestDifference.size() ) {
-                unsigned i = 0;
-                while( i < shortestDifference.size() && shortestDifference[i].nameID == shortestSegments[0].nameID) {
+            int size_of_difference = shortestDifference.size();
+            if(0 < size_of_difference ) {
+                int i = 0;
+                while( i < size_of_difference && shortestDifference[i].nameID == shortestSegments[0].nameID) {
                     ++i;
                 }
-                if(i < shortestDifference.size()) {
+                if(i < size_of_difference ) {
                     shortestSegment2 = shortestDifference[i];
                 }
             }
 
             std::set_difference(alternativeSegments.begin(), alternativeSegments.end(), shortestSegments.begin(), shortestSegments.end(), alternativeDifference.begin(), boost::bind(&Segment::nameID, _1) < boost::bind(&Segment::nameID, _2) );
-            if(0 < alternativeDifference.size() ) {
-                unsigned i = 0;
-                while( i < alternativeDifference.size() && alternativeDifference[i].nameID == alternativeSegments[0].nameID) {
+            size_of_difference = alternativeDifference.size();
+            if(0 < size_of_difference ) {
+                int i = 0;
+                while( i < size_of_difference && alternativeDifference[i].nameID == alternativeSegments[0].nameID) {
                     ++i;
                 }
-                if(i < alternativeDifference.size()) {
+                if(i < size_of_difference ) {
                     alternativeSegment2 = alternativeDifference[i];
                 }
             }
@@ -292,7 +293,7 @@ public:
             routeNames.shortestPathName2 = sEngine.GetEscapedNameForNameID(shortestSegment2.nameID);
 
             routeNames.alternativePathName1 = sEngine.GetEscapedNameForNameID(alternativeSegment1.nameID);
-            routeNames.alternativePathName2 += sEngine.GetEscapedNameForNameID(alternativeSegment2.nameID);
+            routeNames.alternativePathName2 = sEngine.GetEscapedNameForNameID(alternativeSegment2.nameID);
         }
     }
 
@@ -302,7 +303,7 @@ public:
                 "\"status\":";
     }
 
-    inline void BuildTextualDescription(DescriptionFactory & descriptionFactory, http::Reply & reply, const int lengthOfRoute, const SearchEngineT &sEngine, std::vector<Segment> & segmentVector) {
+    inline void BuildTextualDescription(DescriptionFactory & descriptionFactory, http::Reply & reply, const int lengthOfRoute, const SearchEngine &sEngine, std::vector<Segment> & segmentVector) {
         //Segment information has following format:
         //["instruction","streetname",length,position,time,"length","earth_direction",azimuth]
         //Example: ["Turn left","High Street",200,4,10,"200m","NE",22.5]

Extractor/BaseParser.cpp

@@ -0,0 +1,116 @@
+/*
+open source routing machine
+Copyright (C) Dennis Luxen, others 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+#include "BaseParser.h"
+
+BaseParser::BaseParser(ExtractorCallbacks* ec, ScriptingEnvironment& se) :
+extractor_callbacks(ec), scriptingEnvironment(se), luaState(NULL), use_turn_restrictions(true) {
+    luaState = se.getLuaStateForThreadID(0);
+    ReadUseRestrictionsSetting();
+    ReadRestrictionExceptions();
+}
+
+void BaseParser::ReadUseRestrictionsSetting() {
+    if( 0 != luaL_dostring( luaState, "return use_turn_restrictions\n") ) {
+        ERR(lua_tostring( luaState,-1)<< " occured in scripting block");
+    }
+    if( lua_isboolean( luaState, -1) ) {
+        use_turn_restrictions = lua_toboolean(luaState, -1);
+    }
+    if( use_turn_restrictions ) {
+        INFO("Using turn restrictions" );
+    } else {
+        INFO("Ignoring turn restrictions" );
+    }
+}
+
+void BaseParser::ReadRestrictionExceptions() {
+    if(lua_function_exists(luaState, "get_exceptions" )) {
+        //get list of turn restriction exceptions
+        try {
+            luabind::call_function<void>(
+                luaState,
+                "get_exceptions",
+                boost::ref(restriction_exceptions)
+                );
+            INFO("Found " << restriction_exceptions.size() << " exceptions to turn restriction");
+            BOOST_FOREACH(std::string & str, restriction_exceptions) {
+                INFO("   " << str);
+            }
+        } catch (const luabind::error &er) {
+            lua_State* Ler=er.state();
+            report_errors(Ler, -1);
+            ERR(er.what());
+        }
+    } else {
+        INFO("Found no exceptions to turn restrictions");
+    }
+}
+
+void BaseParser::report_errors(lua_State *L, const int status) const {
+    if( 0!=status ) {
+        std::cerr << "-- " << lua_tostring(L, -1) << std::endl;
+        lua_pop(L, 1); // remove error message
+    }
+}
+
+void BaseParser::ParseNodeInLua(ImportNode& n, lua_State* localLuaState) {
+    try {
+        luabind::call_function<void>( localLuaState, "node_function", boost::ref(n) );
+    } catch (const luabind::error &er) {
+        lua_State* Ler=er.state();
+        report_errors(Ler, -1);
+        ERR(er.what());
+    }
+}
+
+void BaseParser::ParseWayInLua(ExtractionWay& w, lua_State* localLuaState) {
+    if(2 > w.path.size()) {
+        return;
+    }
+    try {
+        luabind::call_function<void>( localLuaState, "way_function", boost::ref(w) );
+    } catch (const luabind::error &er) {
+        lua_State* Ler=er.state();
+        report_errors(Ler, -1);
+        ERR(er.what());
+    }
+}
+
+bool BaseParser::ShouldIgnoreRestriction(const std::string& except_tag_string) const {
+    //should this restriction be ignored? yes if there's an overlap between:
+    //a) the list of modes in the except tag of the restriction (except_tag_string), ex: except=bus;bicycle
+    //b) the lua profile defines a hierachy of modes, ex: [access, vehicle, bicycle]
+    
+    if( "" == except_tag_string ) {
+        return false;
+    }
+    
+    //Be warned, this is quadratic work here, but we assume that
+    //only a few exceptions are actually defined.
+    std::vector<std::string> exceptions;
+    boost::algorithm::split_regex(exceptions, except_tag_string, boost::regex("[;][ ]*"));
+    BOOST_FOREACH(std::string& str, exceptions) {
+        if( restriction_exceptions.end() != std::find(restriction_exceptions.begin(), restriction_exceptions.end(), str) ) {
+            return true;
+        }
+    }
+    return false;
+}

Extractor/BaseParser.h

@@ -27,23 +27,32 @@ extern "C" {
 #include <lualib.h>
 }
 
+#include <boost/noncopyable.hpp>
+
+#include "ExtractorCallbacks.h"
 #include "ScriptingEnvironment.h"
 
-template<class ExternalMemoryT, typename NodeT, typename RestrictionT, typename WayT>
-class BaseParser {
+class BaseParser : boost::noncopyable {
 public:
+    BaseParser(ExtractorCallbacks* ec, ScriptingEnvironment& se);
     virtual ~BaseParser() {}
-    virtual bool Init() = 0;
-    virtual void RegisterCallbacks(ExternalMemoryT * externalMemory) = 0;
-    virtual void RegisterScriptingEnvironment(ScriptingEnvironment & _se) = 0;
+    virtual bool ReadHeader() = 0;
     virtual bool Parse() = 0;
 
-    void report_errors(lua_State *L, int status) {
-        if ( status!=0 ) {
-            std::cerr << "-- " << lua_tostring(L, -1) << std::endl;
-            lua_pop(L, 1); // remove error message
-        }
-    }
+    virtual void ParseNodeInLua(ImportNode& n, lua_State* luaStateForThread);
+    virtual void ParseWayInLua(ExtractionWay& n, lua_State* luaStateForThread);
+    virtual void report_errors(lua_State *L, const int status) const;
+
+protected:   
+    virtual void ReadUseRestrictionsSetting();
+    virtual void ReadRestrictionExceptions();
+    virtual bool ShouldIgnoreRestriction(const std::string& except_tag_string) const;
+    
+    ExtractorCallbacks* extractor_callbacks;
+    ScriptingEnvironment& scriptingEnvironment;
+    lua_State* luaState;
+    std::vector<std::string> restriction_exceptions;
+    bool use_turn_restrictions;
 
 };
 

Extractor/ExtractionContainers.cpp

@@ -27,31 +27,31 @@ void ExtractionContainers::PrepareData(const std::string & outputFileName, const
         double time = get_timestamp();
         boost::uint64_t memory_to_use = static_cast<boost::uint64_t>(amountOfRAM) * 1024 * 1024 * 1024;
 
-        cout << "[extractor] Sorting used nodes        ... " << flush;
+        std::cout << "[extractor] Sorting used nodes        ... " << std::flush;
         stxxl::sort(usedNodeIDs.begin(), usedNodeIDs.end(), Cmp(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
 
         time = get_timestamp();
-        cout << "[extractor] Erasing duplicate nodes   ... " << flush;
-        stxxl::vector<NodeID>::iterator NewEnd = unique ( usedNodeIDs.begin(),usedNodeIDs.end() ) ;
+        std::cout << "[extractor] Erasing duplicate nodes   ... " << std::flush;
+        stxxl::vector<NodeID>::iterator NewEnd = std::unique ( usedNodeIDs.begin(),usedNodeIDs.end() ) ;
         usedNodeIDs.resize ( NewEnd - usedNodeIDs.begin() );
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
-        cout << "[extractor] Sorting all nodes         ... " << flush;
+        std::cout << "[extractor] Sorting all nodes         ... " << std::flush;
         stxxl::sort(allNodes.begin(), allNodes.end(), CmpNodeByID(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
-        cout << "[extractor] Sorting used ways         ... " << flush;
+        std::cout << "[extractor] Sorting used ways         ... " << std::flush;
         stxxl::sort(wayStartEndVector.begin(), wayStartEndVector.end(), CmpWayByID(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
 
-        cout << "[extractor] Sorting restrctns. by from... " << flush;
+        std::cout << "[extractor] Sorting restrctns. by from... " << std::flush;
         stxxl::sort(restrictionsVector.begin(), restrictionsVector.end(), CmpRestrictionContainerByFrom(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
 
-        cout << "[extractor] Fixing restriction starts ... " << flush;
+        std::cout << "[extractor] Fixing restriction starts ... " << std::flush;
         STXXLRestrictionsVector::iterator restrictionsIT = restrictionsVector.begin();
         STXXLWayIDStartEndVector::iterator wayStartAndEndEdgeIT = wayStartEndVector.begin();
 
@@ -79,16 +79,16 @@ void ExtractionContainers::PrepareData(const std::string & outputFileName, const
             ++restrictionsIT;
         }
 
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
-        cout << "[extractor] Sorting restrctns. by to  ... " << flush;
+        std::cout << "[extractor] Sorting restrctns. by to  ... " << std::flush;
         stxxl::sort(restrictionsVector.begin(), restrictionsVector.end(), CmpRestrictionContainerByTo(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
 
         time = get_timestamp();
         unsigned usableRestrictionsCounter(0);
-        cout << "[extractor] Fixing restriction ends   ... " << flush;
+        std::cout << "[extractor] Fixing restriction ends   ... " << std::flush;
         restrictionsIT = restrictionsVector.begin();
         wayStartAndEndEdgeIT = wayStartEndVector.begin();
         while(wayStartAndEndEdgeIT != wayStartEndVector.end() && restrictionsIT != restrictionsVector.end()) {
@@ -116,11 +116,11 @@ void ExtractionContainers::PrepareData(const std::string & outputFileName, const
             }
             ++restrictionsIT;
         }
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         INFO("usable restrictions: " << usableRestrictionsCounter );
         //serialize restrictions
-        ofstream restrictionsOutstream;
-        restrictionsOutstream.open(restrictionsFileName.c_str(), ios::binary);
+        std::ofstream restrictionsOutstream;
+        restrictionsOutstream.open(restrictionsFileName.c_str(), std::ios::binary);
         restrictionsOutstream.write((char*)&usableRestrictionsCounter, sizeof(unsigned));
         for(restrictionsIT = restrictionsVector.begin(); restrictionsIT != restrictionsVector.end(); ++restrictionsIT) {
             if(UINT_MAX != restrictionsIT->restriction.fromNode && UINT_MAX != restrictionsIT->restriction.toNode) {
@@ -129,11 +129,11 @@ void ExtractionContainers::PrepareData(const std::string & outputFileName, const
         }
         restrictionsOutstream.close();
 
-        ofstream fout;
-        fout.open(outputFileName.c_str(), ios::binary);
+        std::ofstream fout;
+        fout.open(outputFileName.c_str(), std::ios::binary);
         fout.write((char*)&usedNodeCounter, sizeof(unsigned));
         time = get_timestamp();
-        cout << "[extractor] Confirming/Writing used nodes     ... " << flush;
+        std::cout << "[extractor] Confirming/Writing used nodes     ... " << std::flush;
 
         STXXLNodeVector::iterator nodesIT = allNodes.begin();
         STXXLNodeIDVector::iterator usedNodeIDsIT = usedNodeIDs.begin();
@@ -154,24 +154,24 @@ void ExtractionContainers::PrepareData(const std::string & outputFileName, const
             }
         }
 
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
 
-        cout << "[extractor] setting number of nodes   ... " << flush;
-        ios::pos_type positionInFile = fout.tellp();
-        fout.seekp(ios::beg);
+        std::cout << "[extractor] setting number of nodes   ... " << std::flush;
+        std::ios::pos_type positionInFile = fout.tellp();
+        fout.seekp(std::ios::beg);
         fout.write((char*)&usedNodeCounter, sizeof(unsigned));
         fout.seekp(positionInFile);
 
-        cout << "ok" << endl;
+        std::cout << "ok" << std::endl;
         time = get_timestamp();
 
         // Sort edges by start.
-        cout << "[extractor] Sorting edges by start    ... " << flush;
+        std::cout << "[extractor] Sorting edges by start    ... " << std::flush;
         stxxl::sort(allEdges.begin(), allEdges.end(), CmpEdgeByStartID(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
-        cout << "[extractor] Setting start coords      ... " << flush;
+        std::cout << "[extractor] Setting start coords      ... " << std::flush;
         fout.write((char*)&usedEdgeCounter, sizeof(unsigned));
         // Traverse list of edges and nodes in parallel and set start coord
         nodesIT = allNodes.begin();
@@ -191,16 +191,16 @@ void ExtractionContainers::PrepareData(const std::string & outputFileName, const
                 ++edgeIT;
             }
         }
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
         // Sort Edges by target
-        cout << "[extractor] Sorting edges by target   ... " << flush;
+        std::cout << "[extractor] Sorting edges by target   ... " << std::flush;
         stxxl::sort(allEdges.begin(), allEdges.end(), CmpEdgeByTargetID(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
-        cout << "[extractor] Setting target coords     ... " << flush;
+        std::cout << "[extractor] Setting target coords     ... " << std::flush;
         // Traverse list of edges and nodes in parallel and set target coord
         nodesIT = allNodes.begin();
         edgeIT = allEdges.begin();
@@ -231,22 +231,22 @@ void ExtractionContainers::PrepareData(const std::string & outputFileName, const
                     fout.write((char*)&edgeIT->target, sizeof(unsigned));
                     fout.write((char*)&intDist, sizeof(int));
                     switch(edgeIT->direction) {
-                    case _Way::notSure:
+                    case ExtractionWay::notSure:
                         fout.write((char*)&zero, sizeof(short));
                         break;
-                    case _Way::oneway:
+                    case ExtractionWay::oneway:
                         fout.write((char*)&one, sizeof(short));
                         break;
-                    case _Way::bidirectional:
+                    case ExtractionWay::bidirectional:
                         fout.write((char*)&zero, sizeof(short));
 
                         break;
-                    case _Way::opposite:
+                    case ExtractionWay::opposite:
                         fout.write((char*)&one, sizeof(short));
                         break;
                     default:
-                        cerr << "[error] edge with no direction: " << edgeIT->direction << endl;
-                        assert(false);
+                      std::cerr << "[error] edge with no direction: " << edgeIT->direction << std::endl;
+                      assert(false);
                         break;
                     }
                     fout.write((char*)&intWeight, sizeof(int));
@@ -256,33 +256,34 @@ void ExtractionContainers::PrepareData(const std::string & outputFileName, const
                     fout.write((char*)&edgeIT->isRoundabout, sizeof(bool));
                     fout.write((char*)&edgeIT->ignoreInGrid, sizeof(bool));
                     fout.write((char*)&edgeIT->isAccessRestricted, sizeof(bool));
+                    fout.write((char*)&edgeIT->isContraFlow, sizeof(bool));
+                    ++usedEdgeCounter;
                 }
-                ++usedEdgeCounter;
                 ++edgeIT;
             }
         }
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
-        cout << "[extractor] setting number of edges   ... " << flush;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
+        std::cout << "[extractor] setting number of edges   ... " << std::flush;
 
         fout.seekp(positionInFile);
         fout.write((char*)&usedEdgeCounter, sizeof(unsigned));
         fout.close();
-        cout << "ok" << endl;
+        std::cout << "ok" << std::endl;
         time = get_timestamp();
-        cout << "[extractor] writing street name index ... " << flush;
+        std::cout << "[extractor] writing street name index ... " << std::flush;
         std::string nameOutFileName = (outputFileName + ".names");
-        ofstream nameOutFile(nameOutFileName.c_str(), ios::binary);
+        std::ofstream nameOutFile(nameOutFileName.c_str(), std::ios::binary);
         unsigned sizeOfNameIndex = nameVector.size();
         nameOutFile.write((char *)&(sizeOfNameIndex), sizeof(unsigned));
 
-        BOOST_FOREACH(string str, nameVector) {
+        BOOST_FOREACH(const std::string & str, nameVector) {
             unsigned lengthOfRawString = strlen(str.c_str());
             nameOutFile.write((char *)&(lengthOfRawString), sizeof(unsigned));
             nameOutFile.write(str.c_str(), lengthOfRawString);
         }
 
         nameOutFile.close();
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
 
         //        time = get_timestamp();
         //        cout << "[extractor] writing address list      ... " << flush;
@@ -298,8 +299,8 @@ void ExtractionContainers::PrepareData(const std::string & outputFileName, const
         INFO("Processed " << usedNodeCounter << " nodes and " << usedEdgeCounter << " edges");
 
 
-    } catch ( const exception& e ) {
-        cerr <<  "Caught Execption:" << e.what() << endl;
+    } catch ( const std::exception& e ) {
+      std::cerr <<  "Caught Execption:" << e.what() << std::endl;
     }
 }
 

Extractor/ExtractionContainers.h

@@ -21,17 +21,17 @@
 #ifndef EXTRACTIONCONTAINERS_H_
 #define EXTRACTIONCONTAINERS_H_
 
+#include "ExtractorStructs.h"
+#include "../DataStructures/TimingUtil.h"
+
 #include <boost/foreach.hpp>
 #include <stxxl.h>
 
-#include "ExtractorStructs.h"
-#include "../DataStructures/Util.h"
-
 class ExtractionContainers {
 public:
     typedef stxxl::vector<NodeID> STXXLNodeIDVector;
     typedef stxxl::vector<_Node> STXXLNodeVector;
-    typedef stxxl::vector<_Edge> STXXLEdgeVector;
+    typedef stxxl::vector<InternalExtractorEdge> STXXLEdgeVector;
     typedef stxxl::vector<std::string> STXXLStringVector;
     typedef stxxl::vector<_RawRestrictionContainer> STXXLRestrictionsVector;
     typedef stxxl::vector<_WayIDStartAndEndEdge> STXXLWayIDStartEndVector;

Extractor/ExtractionHelperFunctions.h

@@ -28,12 +28,15 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include <boost/regex.hpp>
 #include <climits>
 
+
 #include "../Util/StringUtil.h"
 
+namespace qi = boost::spirit::qi;
+
 //TODO: Move into LUA
 
 inline bool durationIsValid(const std::string &s) {
-    boost::regex e ("((\\d|\\d\\d):)*(\\d|\\d\\d)",boost::regex_constants::icase|boost::regex_constants::perl);
+    boost::regex e ("((\\d|\\d\\d):(\\d|\\d\\d):(\\d|\\d\\d))|((\\d|\\d\\d):(\\d|\\d\\d))|(\\d|\\d\\d)",boost::regex_constants::icase|boost::regex_constants::perl);
 
     std::vector< std::string > result;
     boost::algorithm::split_regex( result, s, boost::regex( ":" ) ) ;
@@ -42,17 +45,28 @@ inline bool durationIsValid(const std::string &s) {
 }
 
 inline unsigned parseDuration(const std::string &s) {
-    int hours = 0;
-    int minutes = 0;
-    boost::regex e ("((\\d|\\d\\d):)*(\\d|\\d\\d)",boost::regex_constants::icase|boost::regex_constants::perl);
+	unsigned hours = 0;
+    unsigned minutes = 0;
+    unsigned seconds = 0;
+    boost::regex e ("((\\d|\\d\\d):(\\d|\\d\\d):(\\d|\\d\\d))|((\\d|\\d\\d):(\\d|\\d\\d))|(\\d|\\d\\d)",boost::regex_constants::icase|boost::regex_constants::perl);
 
     std::vector< std::string > result;
     boost::algorithm::split_regex( result, s, boost::regex( ":" ) ) ;
     bool matched = regex_match(s, e);
     if(matched) {
-        hours = (result.size()== 2) ?  stringToInt(result[0]) : 0;
-        minutes = (result.size()== 2) ?  stringToInt(result[1]) : stringToInt(result[0]);
-        return 600*(hours*60+minutes);
+    	if(1 == result.size()) {
+    		minutes = stringToInt(result[0]);
+    	}
+    	if(2 == result.size()) {
+    		minutes =  stringToInt(result[1]);
+    		hours = stringToInt(result[0]);
+    	}
+    	if(3 == result.size()) {
+            seconds = stringToInt(result[2]);
+            minutes = stringToInt(result[1]);
+            hours   = stringToInt(result[0]);
+    	}
+        return 10*(3600*hours+60*minutes+seconds);
     }
     return UINT_MAX;
 }
@@ -66,5 +80,4 @@ inline int parseMaxspeed(std::string input) { //call-by-value on purpose.
     return n;
 }
 
-
 #endif /* EXTRACTIONHELPERFUNCTIONS_H_ */

Extractor/ExtractorCallbacks.cpp

@@ -48,58 +48,95 @@ ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers * ext, StringMap * s
     stringMap = strMap;
 }
 
-ExtractorCallbacks::~ExtractorCallbacks() {
-}
+ExtractorCallbacks::~ExtractorCallbacks() { }
 
 /** warning: caller needs to take care of synchronization! */
-bool ExtractorCallbacks::nodeFunction(_Node &n) {
-    if(n.lat <= 85*100000 && n.lat >= -85*100000)
+void ExtractorCallbacks::nodeFunction(const _Node &n) {
+    if(n.lat <= 85*100000 && n.lat >= -85*100000) {
         externalMemory->allNodes.push_back(n);
-    return true;
+    }
 }
 
-bool ExtractorCallbacks::restrictionFunction(_RawRestrictionContainer &r) {
+bool ExtractorCallbacks::restrictionFunction(const _RawRestrictionContainer &r) {
     externalMemory->restrictionsVector.push_back(r);
     return true;
 }
 
 /** warning: caller needs to take care of synchronization! */
-bool ExtractorCallbacks::wayFunction(_Way &w) {
-    /*** Store name of way and split it into edge segments ***/
+void ExtractorCallbacks::wayFunction(ExtractionWay &parsed_way) {
+    if((0 < parsed_way.speed) || (0 < parsed_way.duration)) { //Only true if the way is specified by the speed profile
+        if(UINT_MAX == parsed_way.id){
+            DEBUG("found bogus way with id: " << parsed_way.id << " of size " << parsed_way.path.size());
+            return;
+        }
 
-    if ( w.speed > 0 ) { //Only true if the way is specified by the speed profile
+        if(0 < parsed_way.duration) {
+         //TODO: iterate all way segments and set duration corresponding to the length of each segment
+            parsed_way.speed = parsed_way.duration/(parsed_way.path.size()-1);
+        }
+
+        if(FLT_EPSILON >= fabs(-1. - parsed_way.speed)){
+            DEBUG("found way with bogus speed, id: " << parsed_way.id);
+            return;
+        }
 
         //Get the unique identifier for the street name
-        const StringMap::const_iterator strit = stringMap->find(w.name);
-        if(strit == stringMap->end()) {
-            w.nameID = externalMemory->nameVector.size();
-            externalMemory->nameVector.push_back(w.name);
-            stringMap->insert(StringMap::value_type(w.name, w.nameID));
+        const StringMap::const_iterator string_map_iterator = stringMap->find(parsed_way.name);
+        if(stringMap->end() == string_map_iterator) {
+            parsed_way.nameID = externalMemory->nameVector.size();
+            externalMemory->nameVector.push_back(parsed_way.name);
+            stringMap->insert(std::make_pair(parsed_way.name, parsed_way.nameID));
         } else {
-            w.nameID = strit->second;
+            parsed_way.nameID = string_map_iterator->second;
         }
 
-        if(fabs(-1. - w.speed) < FLT_EPSILON){
-            WARN("found way with bogus speed, id: " << w.id);
-            return true;
-        }
-        if(w.id == UINT_MAX) {
-            WARN("found way with unknown type: " << w.id);
-            return true;
+        if(ExtractionWay::opposite == parsed_way.direction) {
+            std::reverse( parsed_way.path.begin(), parsed_way.path.end() );
+            parsed_way.direction = ExtractionWay::oneway;
         }
 
-        if ( w.direction == _Way::opposite ){
-            std::reverse( w.path.begin(), w.path.end() );
-        }
+        const bool split_bidirectional_edge = (parsed_way.backward_speed > 0) && (parsed_way.speed != parsed_way.backward_speed);
 
-        for(vector< NodeID >::size_type n = 0; n < w.path.size()-1; ++n) {
-            externalMemory->allEdges.push_back(_Edge(w.path[n], w.path[n+1], w.type, w.direction, w.speed, w.nameID, w.roundabout, w.ignoreInGrid, w.isDurationSet, w.isAccessRestricted));
-            externalMemory->usedNodeIDs.push_back(w.path[n]);
+        for(std::vector< NodeID >::size_type n = 0; n < parsed_way.path.size()-1; ++n) {
+            externalMemory->allEdges.push_back(
+                    InternalExtractorEdge(parsed_way.path[n],
+                            parsed_way.path[n+1],
+                            parsed_way.type,
+                            (split_bidirectional_edge ? ExtractionWay::oneway : parsed_way.direction),
+                            parsed_way.speed,
+                            parsed_way.nameID,
+                            parsed_way.roundabout,
+                            parsed_way.ignoreInGrid,
+                            (0 < parsed_way.duration),
+                            parsed_way.isAccessRestricted
+                    )
+            );
+            externalMemory->usedNodeIDs.push_back(parsed_way.path[n]);
         }
-        externalMemory->usedNodeIDs.push_back(w.path.back());
+        externalMemory->usedNodeIDs.push_back(parsed_way.path.back());
 
         //The following information is needed to identify start and end segments of restrictions
-        externalMemory->wayStartEndVector.push_back(_WayIDStartAndEndEdge(w.id, w.path[0], w.path[1], w.path[w.path.size()-2], w.path[w.path.size()-1]));
+        externalMemory->wayStartEndVector.push_back(_WayIDStartAndEndEdge(parsed_way.id, parsed_way.path[0], parsed_way.path[1], parsed_way.path[parsed_way.path.size()-2], parsed_way.path.back()));
+
+        if(split_bidirectional_edge) { //Only true if the way should be split
+            std::reverse( parsed_way.path.begin(), parsed_way.path.end() );
+            for(std::vector< NodeID >::size_type n = 0; n < parsed_way.path.size()-1; ++n) {
+                externalMemory->allEdges.push_back(
+                        InternalExtractorEdge(parsed_way.path[n],
+                                parsed_way.path[n+1],
+                                parsed_way.type,
+                                ExtractionWay::oneway,
+                                parsed_way.backward_speed,
+                                parsed_way.nameID,
+                                parsed_way.roundabout,
+                                parsed_way.ignoreInGrid,
+                                (0 < parsed_way.duration),
+                                parsed_way.isAccessRestricted,
+                                (ExtractionWay::oneway == parsed_way.direction)
+                        )
+                );
+            }
+            externalMemory->wayStartEndVector.push_back(_WayIDStartAndEndEdge(parsed_way.id, parsed_way.path[0], parsed_way.path[1], parsed_way.path[parsed_way.path.size()-2], parsed_way.path.back()));
+        }
     }
-    return true;
 }

Extractor/ExtractorCallbacks.h

@@ -45,12 +45,12 @@ public:
     ~ExtractorCallbacks();
 
     /** warning: caller needs to take care of synchronization! */
-    bool nodeFunction(_Node &n);
+    void nodeFunction(const _Node &n);
 
-    bool restrictionFunction(_RawRestrictionContainer &r);
+    bool restrictionFunction(const _RawRestrictionContainer &r);
 
     /** warning: caller needs to take care of synchronization! */
-    bool wayFunction(_Way &w);
+    void wayFunction(ExtractionWay &w);
 
 };
 

Extractor/ExtractorStructs.h

@@ -34,14 +34,14 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include "../DataStructures/ImportNode.h"
 #include "../DataStructures/NodeCoords.h"
 #include "../DataStructures/Restriction.h"
-#include "../DataStructures/Util.h"
+#include "../DataStructures/TimingUtil.h"
 #include "../typedefs.h"
 
 typedef boost::unordered_map<std::string, NodeID > StringMap;
 typedef boost::unordered_map<std::string, std::pair<int, short> > StringToIntPairMap;
 
-struct _Way {
-    _Way() {
+struct ExtractionWay {
+    ExtractionWay() {
 		Clear();
     }
 	
@@ -50,46 +50,52 @@ struct _Way {
 		nameID = UINT_MAX;
 		path.clear();
 		keyVals.EraseAll();
-        direction = _Way::notSure;
+        direction = ExtractionWay::notSure;
         speed = -1;
+        backward_speed = -1;
+        duration = -1;
         type = -1;
         access = true;
         roundabout = false;
-        isDurationSet = false;
         isAccessRestricted = false;
         ignoreInGrid = false;
     }
 
-    enum {
+    enum Directions {
         notSure = 0, oneway, bidirectional, opposite
-    } direction;
+    };
+    Directions direction;
     unsigned id;
     unsigned nameID;
     std::string name;
     double speed;
+    double backward_speed;
+    double duration;
     short type;
     bool access;
     bool roundabout;
-    bool isDurationSet;
     bool isAccessRestricted;
     bool ignoreInGrid;
     std::vector< NodeID > path;
     HashTable<std::string, std::string> keyVals;
 };
 
-struct _Relation {
-    _Relation() : type(unknown){}
+struct ExtractorRelation {
+    ExtractorRelation() : type(unknown){}
     enum {
         unknown = 0, ferry, turnRestriction
     } type;
     HashTable<std::string, std::string> keyVals;
 };
 
-struct _Edge {
-    _Edge() : start(0), target(0), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false) {};
-    _Edge(NodeID s, NodeID t) : start(s), target(t), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false) { }
-    _Edge(NodeID s, NodeID t, short tp, short d, double sp): start(s), target(t), type(tp), direction(d), speed(sp), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false) { }
-    _Edge(NodeID s, NodeID t, short tp, short d, double sp, unsigned nid, bool isra, bool iing, bool ids, bool iar): start(s), target(t), type(tp), direction(d), speed(sp), nameID(nid), isRoundabout(isra), ignoreInGrid(iing), isDurationSet(ids), isAccessRestricted(iar) {
+struct InternalExtractorEdge {
+    InternalExtractorEdge() : start(0), target(0), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) {};
+    InternalExtractorEdge(NodeID s, NodeID t) : start(s), target(t), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) { }
+    InternalExtractorEdge(NodeID s, NodeID t, short tp, short d, double sp): start(s), target(t), type(tp), direction(d), speed(sp), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) { }
+    InternalExtractorEdge(NodeID s, NodeID t, short tp, short d, double sp, unsigned nid, bool isra, bool iing, bool ids, bool iar): start(s), target(t), type(tp), direction(d), speed(sp), nameID(nid), isRoundabout(isra), ignoreInGrid(iing), isDurationSet(ids), isAccessRestricted(iar), isContraFlow(false) {
+        assert(0 <= type);
+    }
+    InternalExtractorEdge(NodeID s, NodeID t, short tp, short d, double sp, unsigned nid, bool isra, bool iing, bool ids, bool iar, bool icf): start(s), target(t), type(tp), direction(d), speed(sp), nameID(nid), isRoundabout(isra), ignoreInGrid(iing), isDurationSet(ids), isAccessRestricted(iar), isContraFlow(icf) {
         assert(0 <= type);
     }
     NodeID start;
@@ -102,19 +108,21 @@ struct _Edge {
     bool ignoreInGrid;
     bool isDurationSet;
     bool isAccessRestricted;
+    bool isContraFlow;
 
     _Coordinate startCoord;
     _Coordinate targetCoord;
 
-    static _Edge min_value() {
-        return _Edge(0,0);
+    static InternalExtractorEdge min_value() {
+        return InternalExtractorEdge(0,0);
     }
-    static _Edge max_value() {
-        return _Edge((numeric_limits<unsigned>::max)(), (numeric_limits<unsigned>::max)());
+    static InternalExtractorEdge max_value() {
+        return InternalExtractorEdge((std::numeric_limits<unsigned>::max)(), (std::numeric_limits<unsigned>::max)());
     }
-
 };
 
+
+
 struct _WayIDStartAndEndEdge {
     unsigned wayID;
     NodeID firstStart;
@@ -125,10 +133,10 @@ struct _WayIDStartAndEndEdge {
     _WayIDStartAndEndEdge(unsigned w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) :  wayID(w), firstStart(fs), firstTarget(ft), lastStart(ls), lastTarget(lt) {}
 
     static _WayIDStartAndEndEdge min_value() {
-        return _WayIDStartAndEndEdge((numeric_limits<unsigned>::min)(), (numeric_limits<unsigned>::min)(), (numeric_limits<unsigned>::min)(), (numeric_limits<unsigned>::min)(), (numeric_limits<unsigned>::min)());
+        return _WayIDStartAndEndEdge((std::numeric_limits<unsigned>::min)(), (std::numeric_limits<unsigned>::min)(), (std::numeric_limits<unsigned>::min)(), (std::numeric_limits<unsigned>::min)(), (std::numeric_limits<unsigned>::min)());
     }
     static _WayIDStartAndEndEdge max_value() {
-        return _WayIDStartAndEndEdge((numeric_limits<unsigned>::max)(), (numeric_limits<unsigned>::max)(), (numeric_limits<unsigned>::max)(), (numeric_limits<unsigned>::max)(), (numeric_limits<unsigned>::max)());
+        return _WayIDStartAndEndEdge((std::numeric_limits<unsigned>::max)(), (std::numeric_limits<unsigned>::max)(), (std::numeric_limits<unsigned>::max)(), (std::numeric_limits<unsigned>::max)(), (std::numeric_limits<unsigned>::max)());
     }
 };
 
@@ -171,38 +179,33 @@ struct CmpNodeByID : public std::binary_function<_Node, _Node, bool> {
     }
 };
 
-struct CmpEdgeByStartID : public std::binary_function<_Edge, _Edge, bool>
-{
-    typedef _Edge value_type;
-    bool operator ()  (const _Edge & a, const _Edge & b) const {
+struct CmpEdgeByStartID : public std::binary_function<InternalExtractorEdge, InternalExtractorEdge, bool> {
+    typedef InternalExtractorEdge value_type;
+    bool operator ()  (const InternalExtractorEdge & a, const InternalExtractorEdge & b) const {
         return a.start < b.start;
     }
     value_type max_value() {
-        return _Edge::max_value();
+        return InternalExtractorEdge::max_value();
     }
     value_type min_value() {
-        return _Edge::min_value();
+        return InternalExtractorEdge::min_value();
     }
 };
 
-struct CmpEdgeByTargetID : public std::binary_function<_Edge, _Edge, bool>
-{
-    typedef _Edge value_type;
-    bool operator ()  (const _Edge & a, const _Edge & b) const
-    {
+struct CmpEdgeByTargetID : public std::binary_function<InternalExtractorEdge, InternalExtractorEdge, bool> {
+    typedef InternalExtractorEdge value_type;
+    bool operator ()  (const InternalExtractorEdge & a, const InternalExtractorEdge & b) const {
         return a.target < b.target;
     }
-    value_type max_value()
-    {
-        return _Edge::max_value();
+    value_type max_value() {
+        return InternalExtractorEdge::max_value();
     }
-    value_type min_value()
-    {
-        return _Edge::min_value();
+    value_type min_value() {
+        return InternalExtractorEdge::min_value();
     }
 };
 
-inline string GetRandomString() {
+inline std::string GetRandomString() {
     char s[128];
     static const char alphanum[] =
             "0123456789"
@@ -213,7 +216,7 @@ inline string GetRandomString() {
         s[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
     }
     s[127] = 0;
-    return string(s);
+    return std::string(s);
 }
 
 #endif /* EXTRACTORSTRUCTS_H_ */

Extractor/PBFParser.cpp

@@ -0,0 +1,482 @@
+/*
+ open source routing machine
+ Copyright (C) Dennis Luxen, others 2010
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU AFFERO General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ or see http://www.gnu.org/licenses/agpl.txt.
+ */
+
+#include "PBFParser.h"
+
+PBFParser::PBFParser(const char * fileName, ExtractorCallbacks* ec, ScriptingEnvironment& se) : BaseParser( ec, se ) {
+	GOOGLE_PROTOBUF_VERIFY_VERSION;
+	//TODO: What is the bottleneck here? Filling the queue or reading the stuff from disk?
+	//NOTE: With Lua scripting, it is parsing the stuff. I/O is virtually for free.
+	threadDataQueue = boost::make_shared<ConcurrentQueue<_ThreadData*> >( 2500 ); /* Max 2500 items in queue, hardcoded. */
+	input.open(fileName, std::ios::in | std::ios::binary);
+
+	if (!input) {
+		std::cerr << fileName << ": File not found." << std::endl;
+	}
+
+#ifndef NDEBUG
+	blockCount = 0;
+	groupCount = 0;
+#endif
+}
+
+PBFParser::~PBFParser() {
+	if(input.is_open()) {
+		input.close();
+	}
+
+	// Clean up any leftover ThreadData objects in the queue
+	_ThreadData* td;
+	while (threadDataQueue->try_pop(td)) {
+		delete td;
+	}
+	google::protobuf::ShutdownProtobufLibrary();
+
+#ifndef NDEBUG
+	DEBUG("parsed " << blockCount << " blocks from pbf with " << groupCount << " groups");
+#endif
+}
+
+inline bool PBFParser::ReadHeader() {
+	_ThreadData initData;
+	/** read Header */
+	if(!readPBFBlobHeader(input, &initData)) {
+		return false;
+	}
+
+	if(readBlob(input, &initData)) {
+		if(!initData.PBFHeaderBlock.ParseFromArray(&(initData.charBuffer[0]), initData.charBuffer.size() ) ) {
+			std::cerr << "[error] Header not parseable!" << std::endl;
+			return false;
+		}
+
+		for(int i = 0, featureSize = initData.PBFHeaderBlock.required_features_size(); i < featureSize; ++i) {
+			const std::string& feature = initData.PBFHeaderBlock.required_features( i );
+			bool supported = false;
+			if ( "OsmSchema-V0.6" == feature ) {
+				supported = true;
+			}
+			else if ( "DenseNodes" == feature ) {
+				supported = true;
+			}
+
+			if ( !supported ) {
+				std::cerr << "[error] required feature not supported: " << feature.data() << std::endl;
+				return false;
+			}
+		}
+	} else {
+		std::cerr << "[error] blob not loaded!" << std::endl;
+	}
+	return true;
+}
+
+inline void PBFParser::ReadData() {
+	bool keepRunning = true;
+	do {
+		_ThreadData *threadData = new _ThreadData();
+		keepRunning = readNextBlock(input, threadData);
+
+		if (keepRunning) {
+			threadDataQueue->push(threadData);
+		} else {
+			threadDataQueue->push(NULL); // No more data to read, parse stops when NULL encountered
+			delete threadData;
+		}
+	} while(keepRunning);
+}
+
+inline void PBFParser::ParseData() {
+	while (true) {
+		_ThreadData *threadData;
+		threadDataQueue->wait_and_pop(threadData);
+		if( NULL==threadData ) {
+			INFO("Parse Data Thread Finished");
+			threadDataQueue->push(NULL); // Signal end of data for other threads
+			break;
+		}
+
+		loadBlock(threadData);
+
+		for(int i = 0, groupSize = threadData->PBFprimitiveBlock.primitivegroup_size(); i < groupSize; ++i) {
+			threadData->currentGroupID = i;
+			loadGroup(threadData);
+
+			if(threadData->entityTypeIndicator == TypeNode) {
+				parseNode(threadData);
+			}
+			if(threadData->entityTypeIndicator == TypeWay) {
+				parseWay(threadData);
+			}
+			if(threadData->entityTypeIndicator == TypeRelation) {
+				parseRelation(threadData);
+			}
+			if(threadData->entityTypeIndicator == TypeDenseNode) {
+				parseDenseNode(threadData);
+			}
+		}
+
+		delete threadData;
+		threadData = NULL;
+	}
+}
+
+inline bool PBFParser::Parse() {
+	// Start the read and parse threads
+	boost::thread readThread(boost::bind(&PBFParser::ReadData, this));
+
+	//Open several parse threads that are synchronized before call to
+	boost::thread parseThread(boost::bind(&PBFParser::ParseData, this));
+
+	// Wait for the threads to finish
+	readThread.join();
+	parseThread.join();
+
+	return true;
+}
+
+inline void PBFParser::parseDenseNode(_ThreadData * threadData) {
+	const OSMPBF::DenseNodes& dense = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).dense();
+	int denseTagIndex = 0;
+	int64_t m_lastDenseID = 0;
+	int64_t m_lastDenseLatitude = 0;
+	int64_t m_lastDenseLongitude = 0;
+
+	const int number_of_nodes = dense.id_size();
+	std::vector<ImportNode> extracted_nodes_vector(number_of_nodes);
+	for(int i = 0; i < number_of_nodes; ++i) {
+		m_lastDenseID += dense.id( i );
+		m_lastDenseLatitude += dense.lat( i );
+		m_lastDenseLongitude += dense.lon( i );
+		extracted_nodes_vector[i].id = m_lastDenseID;
+		extracted_nodes_vector[i].lat = 100000*( ( double ) m_lastDenseLatitude * threadData->PBFprimitiveBlock.granularity() + threadData->PBFprimitiveBlock.lat_offset() ) / NANO;
+		extracted_nodes_vector[i].lon = 100000*( ( double ) m_lastDenseLongitude * threadData->PBFprimitiveBlock.granularity() + threadData->PBFprimitiveBlock.lon_offset() ) / NANO;
+		while (denseTagIndex < dense.keys_vals_size()) {
+			const int tagValue = dense.keys_vals( denseTagIndex );
+			if( 0==tagValue ) {
+				++denseTagIndex;
+				break;
+			}
+			const int keyValue = dense.keys_vals ( denseTagIndex+1 );
+			const std::string & key = threadData->PBFprimitiveBlock.stringtable().s(tagValue).data();
+			const std::string & value = threadData->PBFprimitiveBlock.stringtable().s(keyValue).data();
+			extracted_nodes_vector[i].keyVals.Add(key, value);
+			denseTagIndex += 2;
+		}
+	}
+
+#pragma omp parallel for schedule ( guided )
+	for(int i = 0; i < number_of_nodes; ++i) {
+	    ImportNode &n = extracted_nodes_vector[i];
+	    ParseNodeInLua( n, scriptingEnvironment.getLuaStateForThreadID(omp_get_thread_num()) );
+	}
+
+	BOOST_FOREACH(ImportNode &n, extracted_nodes_vector) {
+	    extractor_callbacks->nodeFunction(n);
+	}
+}
+
+inline void PBFParser::parseNode(_ThreadData * ) {
+	ERR("Parsing of simple nodes not supported. PBF should use dense nodes");
+}
+
+inline void PBFParser::parseRelation(_ThreadData * threadData) {
+	//TODO: leave early, if relation is not a restriction
+	//TODO: reuse rawRestriction container
+	if( !use_turn_restrictions ) {
+		return;
+	}
+	const OSMPBF::PrimitiveGroup& group = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID );
+	for(int i = 0; i < group.relations_size(); ++i ) {
+		std::string except_tag_string;
+		const OSMPBF::Relation& inputRelation = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).relations(i);
+		bool isRestriction = false;
+		bool isOnlyRestriction = false;
+		for(int k = 0, endOfKeys = inputRelation.keys_size(); k < endOfKeys; ++k) {
+			const std::string & key = threadData->PBFprimitiveBlock.stringtable().s(inputRelation.keys(k));
+			const std::string & val = threadData->PBFprimitiveBlock.stringtable().s(inputRelation.vals(k));
+			if ("type" == key) {
+				if( "restriction" == val) {
+					isRestriction = true;
+				} else {
+					break;
+				}
+			}
+			if ("restriction" == key) {
+				if(val.find("only_") == 0) {
+					isOnlyRestriction = true;
+				}
+			}
+			if ("except" == key) {
+				except_tag_string = val;
+			}
+		}
+
+		if( isRestriction && ShouldIgnoreRestriction(except_tag_string) ) {
+			continue;
+		}
+
+		if(isRestriction) {
+			int64_t lastRef = 0;
+			_RawRestrictionContainer currentRestrictionContainer(isOnlyRestriction);
+			for(int rolesIndex = 0; rolesIndex < inputRelation.roles_sid_size(); ++rolesIndex) {
+				std::string role(threadData->PBFprimitiveBlock.stringtable().s( inputRelation.roles_sid( rolesIndex ) ).data());
+				lastRef += inputRelation.memids(rolesIndex);
+
+				if(!("from" == role || "to" == role || "via" == role)) {
+					continue;
+				}
+
+				switch(inputRelation.types(rolesIndex)) {
+				case 0: //node
+					if("from" == role || "to" == role) { //Only via should be a node
+						continue;
+					}
+					assert("via" == role);
+					if(UINT_MAX != currentRestrictionContainer.viaNode) {
+						currentRestrictionContainer.viaNode = UINT_MAX;
+					}
+					assert(UINT_MAX == currentRestrictionContainer.viaNode);
+					currentRestrictionContainer.restriction.viaNode = lastRef;
+					break;
+				case 1: //way
+					assert("from" == role || "to" == role || "via" == role);
+					if("from" == role) {
+						currentRestrictionContainer.fromWay = lastRef;
+					}
+					if ("to" == role) {
+						currentRestrictionContainer.toWay = lastRef;
+					}
+					if ("via" == role) {
+						assert(currentRestrictionContainer.restriction.toNode == UINT_MAX);
+						currentRestrictionContainer.viaNode = lastRef;
+					}
+					break;
+				case 2: //relation, not used. relations relating to relations are evil.
+					continue;
+					assert(false);
+					break;
+
+				default: //should not happen
+					//cout << "unknown";
+					assert(false);
+					break;
+				}
+			}
+			if(!extractor_callbacks->restrictionFunction(currentRestrictionContainer)) {
+				std::cerr << "[PBFParser] relation not parsed" << std::endl;
+			}
+		}
+	}
+}
+
+inline void PBFParser::parseWay(_ThreadData * threadData) {
+	const int number_of_ways = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways_size();
+	std::vector<ExtractionWay> parsed_way_vector(number_of_ways);
+	for(int i = 0; i < number_of_ways; ++i) {
+		const OSMPBF::Way& inputWay = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways( i );
+		parsed_way_vector[i].id = inputWay.id();
+		unsigned pathNode(0);
+		const int number_of_referenced_nodes = inputWay.refs_size();
+		for(int j = 0; j < number_of_referenced_nodes; ++j) {
+			pathNode += inputWay.refs(j);
+			parsed_way_vector[i].path.push_back(pathNode);
+		}
+		assert(inputWay.keys_size() == inputWay.vals_size());
+		const int number_of_keys = inputWay.keys_size();
+		for(int j = 0; j < number_of_keys; ++j) {
+			const std::string & key = threadData->PBFprimitiveBlock.stringtable().s(inputWay.keys(j));
+			const std::string & val = threadData->PBFprimitiveBlock.stringtable().s(inputWay.vals(j));
+			parsed_way_vector[i].keyVals.Add(key, val);
+		}
+	}
+
+#pragma omp parallel for schedule ( guided )
+	for(int i = 0; i < number_of_ways; ++i) {
+	    ExtractionWay & w = parsed_way_vector[i];
+	    ParseWayInLua( w, scriptingEnvironment.getLuaStateForThreadID(omp_get_thread_num()) );
+	}
+
+	BOOST_FOREACH(ExtractionWay & w, parsed_way_vector) {
+	    extractor_callbacks->wayFunction(w);
+	}
+}
+
+inline void PBFParser::loadGroup(_ThreadData * threadData) {
+#ifndef NDEBUG
+	++groupCount;
+#endif
+
+	const OSMPBF::PrimitiveGroup& group = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID );
+	threadData->entityTypeIndicator = 0;
+	if ( group.nodes_size() != 0 ) {
+		threadData->entityTypeIndicator = TypeNode;
+	}
+	if ( group.ways_size() != 0 ) {
+		threadData->entityTypeIndicator = TypeWay;
+	}
+	if ( group.relations_size() != 0 ) {
+		threadData->entityTypeIndicator = TypeRelation;
+	}
+	if ( group.has_dense() )  {
+		threadData->entityTypeIndicator = TypeDenseNode;
+		assert( group.dense().id_size() != 0 );
+	}
+	assert( threadData->entityTypeIndicator != 0 );
+}
+
+inline void PBFParser::loadBlock(_ThreadData * threadData) {
+#ifndef NDEBUG
+	++blockCount;
+#endif
+	threadData->currentGroupID = 0;
+	threadData->currentEntityID = 0;
+}
+
+inline bool PBFParser::readPBFBlobHeader(std::fstream& stream, _ThreadData * threadData) {
+	int size(0);
+	stream.read((char *)&size, sizeof(int));
+	size = swapEndian(size);
+	if(stream.eof()) {
+		return false;
+	}
+	if ( size > MAX_BLOB_HEADER_SIZE || size < 0 ) {
+		return false;
+	}
+	char *data = new char[size];
+	stream.read(data, size*sizeof(data[0]));
+
+	bool dataSuccessfullyParsed = (threadData->PBFBlobHeader).ParseFromArray( data, size);
+	delete[] data;
+	return dataSuccessfullyParsed;
+}
+
+inline bool PBFParser::unpackZLIB(std::fstream &, _ThreadData * threadData) {
+	unsigned rawSize = threadData->PBFBlob.raw_size();
+	char* unpackedDataArray = new char[rawSize];
+	z_stream compressedDataStream;
+	compressedDataStream.next_in = ( unsigned char* ) threadData->PBFBlob.zlib_data().data();
+	compressedDataStream.avail_in = threadData->PBFBlob.zlib_data().size();
+	compressedDataStream.next_out = ( unsigned char* ) unpackedDataArray;
+	compressedDataStream.avail_out = rawSize;
+	compressedDataStream.zalloc = Z_NULL;
+	compressedDataStream.zfree = Z_NULL;
+	compressedDataStream.opaque = Z_NULL;
+	int ret = inflateInit( &compressedDataStream );
+	if ( ret != Z_OK ) {
+		std::cerr << "[error] failed to init zlib stream" << std::endl;
+		delete[] unpackedDataArray;
+		return false;
+	}
+
+	ret = inflate( &compressedDataStream, Z_FINISH );
+	if ( ret != Z_STREAM_END ) {
+		std::cerr << "[error] failed to inflate zlib stream" << std::endl;
+		std::cerr << "[error] Error type: " << ret << std::endl;
+		delete[] unpackedDataArray;
+		return false;
+	}
+
+	ret = inflateEnd( &compressedDataStream );
+	if ( ret != Z_OK ) {
+		std::cerr << "[error] failed to deinit zlib stream" << std::endl;
+		delete[] unpackedDataArray;
+		return false;
+	}
+
+	threadData->charBuffer.clear(); threadData->charBuffer.resize(rawSize);
+	std::copy(unpackedDataArray, unpackedDataArray + rawSize, threadData->charBuffer.begin());
+	delete[] unpackedDataArray;
+	return true;
+}
+
+inline bool PBFParser::unpackLZMA(std::fstream &, _ThreadData * ) {
+	return false;
+}
+
+inline bool PBFParser::readBlob(std::fstream& stream, _ThreadData * threadData) {
+	if(stream.eof()) {
+		return false;
+	}
+
+	const int size = threadData->PBFBlobHeader.datasize();
+	if ( size < 0 || size > MAX_BLOB_SIZE ) {
+		std::cerr << "[error] invalid Blob size:" << size << std::endl;
+		return false;
+	}
+
+	char* data = new char[size];
+	stream.read(data, sizeof(data[0])*size);
+
+	if ( !threadData->PBFBlob.ParseFromArray( data, size ) ) {
+		std::cerr << "[error] failed to parse blob" << std::endl;
+		delete[] data;
+		return false;
+	}
+
+	if ( threadData->PBFBlob.has_raw() ) {
+		const std::string& data = threadData->PBFBlob.raw();
+		threadData->charBuffer.clear();
+		threadData->charBuffer.resize( data.size() );
+		std::copy(data.begin(), data.end(), threadData->charBuffer.begin());
+	} else if ( threadData->PBFBlob.has_zlib_data() ) {
+		if ( !unpackZLIB(stream, threadData) ) {
+			std::cerr << "[error] zlib data encountered that could not be unpacked" << std::endl;
+			delete[] data;
+			return false;
+		}
+	} else if ( threadData->PBFBlob.has_lzma_data() ) {
+		if ( !unpackLZMA(stream, threadData) ) {
+			std::cerr << "[error] lzma data encountered that could not be unpacked" << std::endl;
+		}
+		delete[] data;
+		return false;
+	} else {
+		std::cerr << "[error] Blob contains no data" << std::endl;
+		delete[] data;
+		return false;
+	}
+	delete[] data;
+	return true;
+}
+
+bool PBFParser::readNextBlock(std::fstream& stream, _ThreadData * threadData) {
+	if(stream.eof()) {
+		return false;
+	}
+
+	if ( !readPBFBlobHeader(stream, threadData) ){
+		return false;
+	}
+
+	if ( threadData->PBFBlobHeader.type() != "OSMData" ) {
+		return false;
+	}
+
+	if ( !readBlob(stream, threadData) ) {
+		return false;
+	}
+
+	if ( !threadData->PBFprimitiveBlock.ParseFromArray( &(threadData->charBuffer[0]), threadData-> charBuffer.size() ) ) {
+		ERR("failed to parse PrimitiveBlock");
+		return false;
+	}
+	return true;
+}

Extractor/PBFParser.h

@@ -1,47 +1,45 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
+ open source routing machine
+ Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU AFFERO General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
+ You should have received a copy of the GNU Affero General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ or see http://www.gnu.org/licenses/agpl.txt.
  */
 
 #ifndef PBFPARSER_H_
 #define PBFPARSER_H_
 
-#include <zlib.h>
+#include "../DataStructures/HashTable.h"
+#include "../DataStructures/ConcurrentQueue.h"
+#include "../Util/MachineInfo.h"
+#include "../Util/OpenMPWrapper.h"
+#include "../typedefs.h"
+
+#include "BaseParser.h"
+#include <boost/shared_ptr.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/ref.hpp>
-#include <boost/shared_ptr.hpp>
 
 #include <osmpbf/fileformat.pb.h>
 #include <osmpbf/osmformat.pb.h>
 
-#include "../typedefs.h"
+#include <zlib.h>
 
-#include "BaseParser.h"
-#include "ExtractorCallbacks.h"
-#include "ExtractorStructs.h"
-#include "ScriptingEnvironment.h"
-#include "../DataStructures/HashTable.h"
-#include "../DataStructures/ConcurrentQueue.h"
-#include "../Util/OpenMPWrapper.h"
 
-class PBFParser : public BaseParser<ExtractorCallbacks, _Node, _RawRestrictionContainer, _Way> {
 
-//    typedef BaseParser<ExtractorCallbacks, _Node, _RawRestrictionContainer, _Way> super;
+class PBFParser : public BaseParser {
 
     enum EntityType {
         TypeNode = 1,
@@ -50,11 +48,6 @@ class PBFParser : public BaseParser<ExtractorCallbacks, _Node, _RawRestrictionCo
         TypeDenseNode = 8
     } ;
 
-    enum Endianness {
-        LittleEndian = 1,
-        BigEndian = 2
-    };
-
     struct _ThreadData {
         int currentGroupID;
         int currentEntityID;
@@ -70,512 +63,27 @@ class PBFParser : public BaseParser<ExtractorCallbacks, _Node, _RawRestrictionCo
     };
 
 public:
-    PBFParser(const char * fileName) : externalMemory(NULL){
-        GOOGLE_PROTOBUF_VERIFY_VERSION;
-        //TODO: What is the bottleneck here? Filling the queue or reading the stuff from disk?
-        //NOTE: With Lua scripting, it is parsing the stuff. I/O is virtually for free.
-        threadDataQueue = boost::make_shared<ConcurrentQueue<_ThreadData*> >( 2500 ); /* Max 2500 items in queue, hardcoded. */
-        input.open(fileName, std::ios::in | std::ios::binary);
+    PBFParser(const char * fileName, ExtractorCallbacks* ec, ScriptingEnvironment& se);
+    virtual ~PBFParser();
 
-        if (!input) {
-            std::cerr << fileName << ": File not found." << std::endl;
-        }
-
-#ifndef NDEBUG
-        blockCount = 0;
-        groupCount = 0;
-#endif
-    }
-
-    void RegisterCallbacks(ExtractorCallbacks * em) {
-        externalMemory = em;
-    }
-
-    //call by value, but who cares. It is done once.
-    void RegisterScriptingEnvironment(ScriptingEnvironment & _se) {
-        scriptingEnvironment = _se;
-    }
-
-    ~PBFParser() {
-        if(input.is_open())
-            input.close();
-
-        // Clean up any leftover ThreadData objects in the queue
-        _ThreadData* td;
-        while (threadDataQueue->try_pop(td)) {
-            delete td;
-        }
-        google::protobuf::ShutdownProtobufLibrary();
-
-#ifndef NDEBUG
-        DEBUG("parsed " << blockCount << " blocks from pbf with " << groupCount << " groups");
-#endif
-    }
-
-    inline bool Init() {
-        _ThreadData initData;
-        /** read Header */
-        if(!readPBFBlobHeader(input, &initData)) {
-            return false;
-        }
-
-        if(readBlob(input, &initData)) {
-            if(!initData.PBFHeaderBlock.ParseFromArray(&(initData.charBuffer[0]), initData.charBuffer.size() ) ) {
-                std::cerr << "[error] Header not parseable!" << std::endl;
-                return false;
-            }
-
-            for(int i = 0, featureSize = initData.PBFHeaderBlock.required_features_size(); i < featureSize; ++i) {
-                const std::string& feature = initData.PBFHeaderBlock.required_features( i );
-                bool supported = false;
-                if ( "OsmSchema-V0.6" == feature )
-                    supported = true;
-                else if ( "DenseNodes" == feature )
-                    supported = true;
-
-                if ( !supported ) {
-                    std::cerr << "[error] required feature not supported: " << feature.data() << std::endl;
-                    return false;
-                }
-            }
-        } else {
-            std::cerr << "[error] blob not loaded!" << std::endl;
-        }
-        return true;
-    }
-
-    inline void ReadData() {
-        bool keepRunning = true;
-        do {
-            _ThreadData *threadData = new _ThreadData();
-            keepRunning = readNextBlock(input, threadData);
-
-            if (keepRunning)
-                threadDataQueue->push(threadData);
-            else {
-                threadDataQueue->push(NULL); // No more data to read, parse stops when NULL encountered
-                delete threadData;
-            }
-        } while(keepRunning);
-    }
-
-    inline void ParseData() {
-        while (1) {
-            _ThreadData *threadData;
-            threadDataQueue->wait_and_pop(threadData);
-            if (threadData == NULL) {
-                INFO("Parse Data Thread Finished");
-                threadDataQueue->push(NULL); // Signal end of data for other threads
-                break;
-            }
-
-            loadBlock(threadData);
-
-            for(int i = 0, groupSize = threadData->PBFprimitiveBlock.primitivegroup_size(); i < groupSize; ++i) {
-                threadData->currentGroupID = i;
-                loadGroup(threadData);
-
-                if(threadData->entityTypeIndicator == TypeNode)
-                    parseNode(threadData);
-                if(threadData->entityTypeIndicator == TypeWay)
-                    parseWay(threadData);
-                if(threadData->entityTypeIndicator == TypeRelation)
-                    parseRelation(threadData);
-                if(threadData->entityTypeIndicator == TypeDenseNode)
-                    parseDenseNode(threadData);
-            }
-
-            delete threadData;
-            threadData = NULL;
-        }
-    }
-
-    inline bool Parse() {
-        // Start the read and parse threads
-        boost::thread readThread(boost::bind(&PBFParser::ReadData, this));
-
-        //Open several parse threads that are synchronized before call to
-        boost::thread parseThread(boost::bind(&PBFParser::ParseData, this));
-
-        // Wait for the threads to finish
-        readThread.join();
-        parseThread.join();
-
-        return true;
-    }
+    inline bool ReadHeader();
+	inline bool Parse();
 
 private:
+    inline void ReadData();
+    inline void ParseData();
+    inline void parseDenseNode(_ThreadData * threadData);
+    inline void parseNode(_ThreadData * );
+    inline void parseRelation(_ThreadData * threadData);
+    inline void parseWay(_ThreadData * threadData);
 
-    inline void parseDenseNode(_ThreadData * threadData) {
-        const OSMPBF::DenseNodes& dense = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).dense();
-        int denseTagIndex = 0;
-        int m_lastDenseID = 0;
-        int m_lastDenseLatitude = 0;
-        int m_lastDenseLongitude = 0;
-
-        ImportNode n;
-		std::vector<ImportNode> nodesToParse;
-        for(int i = 0, idSize = dense.id_size(); i < idSize; ++i) {
-			n.Clear();
-            m_lastDenseID += dense.id( i );
-            m_lastDenseLatitude += dense.lat( i );
-            m_lastDenseLongitude += dense.lon( i );
-            n.id = m_lastDenseID;
-            n.lat = 100000*( ( double ) m_lastDenseLatitude * threadData->PBFprimitiveBlock.granularity() +threadData-> PBFprimitiveBlock.lat_offset() ) / NANO;
-            n.lon = 100000*( ( double ) m_lastDenseLongitude * threadData->PBFprimitiveBlock.granularity() + threadData->PBFprimitiveBlock.lon_offset() ) / NANO;
-            while (denseTagIndex < dense.keys_vals_size()) {
-                const int tagValue = dense.keys_vals( denseTagIndex );
-                if(tagValue == 0) {
-                    ++denseTagIndex;
-                    break;
-                }
-                const int keyValue = dense.keys_vals ( denseTagIndex+1 );
-                const std::string & key = threadData->PBFprimitiveBlock.stringtable().s(tagValue).data();
-                const std::string & value = threadData->PBFprimitiveBlock.stringtable().s(keyValue).data();
-                n.keyVals.Add(key, value);
-                denseTagIndex += 2;
-            }
-            nodesToParse.push_back(n);
-        }
-
-        unsigned endi_nodes = nodesToParse.size();
-#pragma omp parallel for schedule ( guided )
-        for(unsigned i = 0; i < endi_nodes; ++i) {
-            ImportNode &n = nodesToParse[i];
-            /** Pass the unpacked node to the LUA call back **/
-            try {
-                luabind::call_function<int>(
-                        scriptingEnvironment.getLuaStateForThreadID(omp_get_thread_num()),
-                        "node_function",
-                        boost::ref(n)
-                );
-            } catch (const luabind::error &er) {
-                lua_State* Ler=er.state();
-                report_errors(Ler, -1);
-                ERR(er.what());
-            }
-//            catch (...) {
-//                ERR("Unknown error occurred during PBF dense node parsing!");
-//            }
-        }
-
-
-        BOOST_FOREACH(ImportNode &n, nodesToParse) {
-            if(!externalMemory->nodeFunction(n))
-                std::cerr << "[PBFParser] dense node not parsed" << std::endl;
-        }
-    }
-
-    inline void parseNode(_ThreadData * ) {
-        ERR("Parsing of simple nodes not supported. PBF should use dense nodes");
-    }
-
-    inline void parseRelation(_ThreadData * threadData) {
-		//TODO: leave early, if relatio is not a restriction
-		//TODO: reuse rawRestriction container
-        const OSMPBF::PrimitiveGroup& group = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID );
-        for(int i = 0; i < group.relations_size(); ++i ) {
-            const OSMPBF::Relation& inputRelation = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).relations(i);
-            bool isRestriction = false;
-            bool isOnlyRestriction = false;
-            for(int k = 0, endOfKeys = inputRelation.keys_size(); k < endOfKeys; ++k) {
-                const std::string & key = threadData->PBFprimitiveBlock.stringtable().s(inputRelation.keys(k));
-                const std::string & val = threadData->PBFprimitiveBlock.stringtable().s(inputRelation.vals(k));
-                if ("type" == key) {
-					if( "restriction" == val)
-                    	isRestriction = true;
-					else 
-						break;
-                }
-                if ("restriction" == key) {
-                    if(val.find("only_") == 0)
-                        isOnlyRestriction = true;
-                }
-
-            }
-            if(isRestriction) {
-                long long lastRef = 0;
-                _RawRestrictionContainer currentRestrictionContainer(isOnlyRestriction);
-                for(int rolesIndex = 0; rolesIndex < inputRelation.roles_sid_size(); ++rolesIndex) {
-                    std::string role(threadData->PBFprimitiveBlock.stringtable().s( inputRelation.roles_sid( rolesIndex ) ).data());
-                    lastRef += inputRelation.memids(rolesIndex);
-
-                    if(false == ("from" == role || "to" == role || "via" == role)) {
-                        continue;
-                    }
-
-                    switch(inputRelation.types(rolesIndex)) {
-                    case 0: //node
-                        if("from" == role || "to" == role) //Only via should be a node
-                            continue;
-                        assert("via" == role);
-                        if(UINT_MAX != currentRestrictionContainer.viaNode)
-                            currentRestrictionContainer.viaNode = UINT_MAX;
-                        assert(UINT_MAX == currentRestrictionContainer.viaNode);
-                        currentRestrictionContainer.restriction.viaNode = lastRef;
-                        break;
-                    case 1: //way
-                        assert("from" == role || "to" == role || "via" == role);
-                        if("from" == role) {
-                            currentRestrictionContainer.fromWay = lastRef;
-                        }
-                        if ("to" == role) {
-                            currentRestrictionContainer.toWay = lastRef;
-                        }
-                        if ("via" == role) {
-                            assert(currentRestrictionContainer.restriction.toNode == UINT_MAX);
-                            currentRestrictionContainer.viaNode = lastRef;
-                        }
-                        break;
-                    case 2: //relation, not used. relations relating to relations are evil.
-                        continue;
-                        assert(false);
-                        break;
-
-                    default: //should not happen
-                        //cout << "unknown";
-                        assert(false);
-                        break;
-                    }
-                }
-                //                if(UINT_MAX != currentRestriction.viaNode) {
-                //                    cout << "restr from " << currentRestriction.from << " via ";
-                //                    cout << "node " << currentRestriction.viaNode;
-                //                    cout << " to " << currentRestriction.to << endl;
-                //                }
-                if(!externalMemory->restrictionFunction(currentRestrictionContainer))
-                    std::cerr << "[PBFParser] relation not parsed" << std::endl;
-            }
-        }
-    }
-
-    inline void parseWay(_ThreadData * threadData) {
-            _Way w;
-            std::vector<_Way> waysToParse(threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways_size());
-            for(int i = 0, ways_size = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways_size(); i < ways_size; ++i) {
-				w.Clear();
-                const OSMPBF::Way& inputWay = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways( i );
-                w.id = inputWay.id();
-                unsigned pathNode(0);
-                for(int i = 0; i < inputWay.refs_size(); ++i) {
-                    pathNode += inputWay.refs(i);
-                    w.path.push_back(pathNode);
-                }
-                assert(inputWay.keys_size() == inputWay.vals_size());
-                for(int i = 0; i < inputWay.keys_size(); ++i) {
-                    const std::string & key = threadData->PBFprimitiveBlock.stringtable().s(inputWay.keys(i));
-                    const std::string & val = threadData->PBFprimitiveBlock.stringtable().s(inputWay.vals(i));
-                    w.keyVals.Add(key, val);
-                }
-
-                waysToParse.push_back(w);
-            }
-
-            unsigned endi_ways = waysToParse.size();
-#pragma omp parallel for schedule ( guided )
-            for(unsigned i = 0; i < endi_ways; ++i) {
-                _Way & w = waysToParse[i];
-                /** Pass the unpacked way to the LUA call back **/
-                try {
-                    luabind::call_function<int>(
-                        scriptingEnvironment.getLuaStateForThreadID(omp_get_thread_num()),
-                        "way_function",
-                        boost::ref(w),
-                        w.path.size()
-                    );
-
-                } catch (const luabind::error &er) {
-                    lua_State* Ler=er.state();
-                    report_errors(Ler, -1);
-                    ERR(er.what());
-                }
-//                catch (...) {
-//                    ERR("Unknown error!");
-//                }
-            }
-
-            BOOST_FOREACH(_Way & w, waysToParse) {
-                if(!externalMemory->wayFunction(w)) {
-                    std::cerr << "[PBFParser] way not parsed" << std::endl;
-                }
-            }
-    }
-
-    inline void loadGroup(_ThreadData * threadData) {
-#ifndef NDEBUG
-        ++groupCount;
-#endif
-		
-        const OSMPBF::PrimitiveGroup& group = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID );
-        threadData->entityTypeIndicator = 0;
-        if ( group.nodes_size() != 0 ) {
-            threadData->entityTypeIndicator = TypeNode;
-        }
-        if ( group.ways_size() != 0 ) {
-            threadData->entityTypeIndicator = TypeWay;
-        }
-        if ( group.relations_size() != 0 ) {
-            threadData->entityTypeIndicator = TypeRelation;
-        }
-        if ( group.has_dense() )  {
-            threadData->entityTypeIndicator = TypeDenseNode;
-            assert( group.dense().id_size() != 0 );
-        }
-        assert( threadData->entityTypeIndicator != 0 );
-    }
-
-    inline void loadBlock(_ThreadData * threadData) {
-#ifndef NDEBUG
-        ++blockCount;
-#endif
-        threadData->currentGroupID = 0;
-        threadData->currentEntityID = 0;
-    }
-
-    /* Reverses Network Byte Order into something usable, compiles down to a bswap-mov combination */
-    inline unsigned swapEndian(unsigned x) const {
-        if(getMachineEndianness() == LittleEndian)
-            return ( (x>>24) | ((x<<8) & 0x00FF0000) | ((x>>8) & 0x0000FF00) | (x<<24) );
-        return x;
-    }
-
-    inline bool readPBFBlobHeader(std::fstream& stream, _ThreadData * threadData) {
-        int size(0);
-        stream.read((char *)&size, sizeof(int));
-        size = swapEndian(size);
-        if(stream.eof()) {
-            return false;
-        }
-        if ( size > MAX_BLOB_HEADER_SIZE || size < 0 ) {
-            return false;
-        }
-        char *data = new char[size];
-        stream.read(data, size*sizeof(data[0]));
-
-        bool dataSuccessfullyParsed = (threadData->PBFBlobHeader).ParseFromArray( data, size);
-        delete[] data;
-        return dataSuccessfullyParsed;
-    }
-
-    inline bool unpackZLIB(std::fstream &, _ThreadData * threadData) {
-        unsigned rawSize = threadData->PBFBlob.raw_size();
-        char* unpackedDataArray = new char[rawSize];
-        z_stream compressedDataStream;
-        compressedDataStream.next_in = ( unsigned char* ) threadData->PBFBlob.zlib_data().data();
-        compressedDataStream.avail_in = threadData->PBFBlob.zlib_data().size();
-        compressedDataStream.next_out = ( unsigned char* ) unpackedDataArray;
-        compressedDataStream.avail_out = rawSize;
-        compressedDataStream.zalloc = Z_NULL;
-        compressedDataStream.zfree = Z_NULL;
-        compressedDataStream.opaque = Z_NULL;
-        int ret = inflateInit( &compressedDataStream );
-        if ( ret != Z_OK ) {
-            std::cerr << "[error] failed to init zlib stream" << std::endl;
-            delete[] unpackedDataArray;
-            return false;
-        }
-
-        ret = inflate( &compressedDataStream, Z_FINISH );
-        if ( ret != Z_STREAM_END ) {
-            std::cerr << "[error] failed to inflate zlib stream" << std::endl;
-            std::cerr << "[error] Error type: " << ret << std::endl;
-            delete[] unpackedDataArray;
-            return false;
-        }
-
-        ret = inflateEnd( &compressedDataStream );
-        if ( ret != Z_OK ) {
-            std::cerr << "[error] failed to deinit zlib stream" << std::endl;
-            delete[] unpackedDataArray;
-            return false;
-        }
-
-        threadData->charBuffer.clear(); threadData->charBuffer.resize(rawSize);
-		std::copy(unpackedDataArray, unpackedDataArray + rawSize, threadData->charBuffer.begin());
-        delete[] unpackedDataArray;
-        return true;
-    }
-
-    inline bool unpackLZMA(std::fstream &, _ThreadData * ) const {
-        return false;
-    }
-
-    inline bool readBlob(std::fstream& stream, _ThreadData * threadData) {
-        if(stream.eof())
-            return false;
-
-        const int size = threadData->PBFBlobHeader.datasize();
-        if ( size < 0 || size > MAX_BLOB_SIZE ) {
-            std::cerr << "[error] invalid Blob size:" << size << std::endl;
-            return false;
-        }
-
-        char* data = new char[size];
-        stream.read(data, sizeof(data[0])*size);
-
-        if ( !threadData->PBFBlob.ParseFromArray( data, size ) ) {
-            std::cerr << "[error] failed to parse blob" << std::endl;
-            delete[] data;
-            return false;
-        }
-
-        if ( threadData->PBFBlob.has_raw() ) {
-            const std::string& data = threadData->PBFBlob.raw();
-            threadData->charBuffer.clear();
-            threadData->charBuffer.resize( data.size() );
-			std::copy(data.begin(), data.end(), threadData->charBuffer.begin());
-        } else if ( threadData->PBFBlob.has_zlib_data() ) {
-            if ( !unpackZLIB(stream, threadData) ) {
-                std::cerr << "[error] zlib data encountered that could not be unpacked" << std::endl;
-	            delete[] data;
-                return false;
-            }
-        } else if ( threadData->PBFBlob.has_lzma_data() ) {
-            if ( !unpackLZMA(stream, threadData) )
-                std::cerr << "[error] lzma data encountered that could not be unpacked" << std::endl;
-            delete[] data;
-            return false;
-        } else {
-            std::cerr << "[error] Blob contains no data" << std::endl;
-            delete[] data;
-            return false;
-        }
-        delete[] data;
-        return true;
-    }
-
-    inline bool readNextBlock(std::fstream& stream, _ThreadData * threadData) {
-        if(stream.eof()) {
-            return false;
-        }
-
-        if ( !readPBFBlobHeader(stream, threadData) ){
-            return false;
-        }
-
-        if ( threadData->PBFBlobHeader.type() != "OSMData" ) {
-            return false;
-        }
-
-        if ( !readBlob(stream, threadData) ) {
-            return false;
-        }
-
-        if ( !threadData->PBFprimitiveBlock.ParseFromArray( &(threadData->charBuffer[0]), threadData-> charBuffer.size() ) ) {
-            ERR("failed to parse PrimitiveBlock");
-            return false;
-        }
-        return true;
-    }
-
-	//Is optimized to a single 'mov eax,1' on GCC, clang and icc using -O3
-    inline Endianness getMachineEndianness() const {
-        int i(1);
-        char *p = (char *) &i;
-        if (1 == p[0])
-            return LittleEndian;
-        return BigEndian;
-    }
+    inline void loadGroup(_ThreadData * threadData);
+    inline void loadBlock(_ThreadData * threadData);
+    inline bool readPBFBlobHeader(std::fstream& stream, _ThreadData * threadData);
+    inline bool unpackZLIB(std::fstream &, _ThreadData * threadData);
+    inline bool unpackLZMA(std::fstream &, _ThreadData * );
+    inline bool readBlob(std::fstream& stream, _ThreadData * threadData) ;
+    inline bool readNextBlock(std::fstream& stream, _ThreadData * threadData);
 
     static const int NANO = 1000 * 1000 * 1000;
     static const int MAX_BLOB_HEADER_SIZE = 64 * 1024;
@@ -586,15 +94,9 @@ private:
     unsigned groupCount;
     unsigned blockCount;
 #endif
-	
-    ExtractorCallbacks * externalMemory;
-    /* the input stream to parse */
-    std::fstream input;
 
-    /* ThreadData Queue */
+    std::fstream input;     // the input stream to parse
     boost::shared_ptr<ConcurrentQueue < _ThreadData* > > threadDataQueue;
-
-    ScriptingEnvironment scriptingEnvironment;
 };
 
 #endif /* PBFPARSER_H_ */

Extractor/ScriptingEnvironment.cpp

@@ -18,15 +18,7 @@
  or see http://www.gnu.org/licenses/agpl.txt.
  */
 
-extern "C" {
-#include <lua.h>
-#include <lauxlib.h>
-#include <lualib.h>
-}
-
 #include "ScriptingEnvironment.h"
-#include "../typedefs.h"
-#include "../Util/OpenMPWrapper.h"
 
 ScriptingEnvironment::ScriptingEnvironment() {}
 ScriptingEnvironment::ScriptingEnvironment(const char * fileName) {
@@ -44,6 +36,8 @@ ScriptingEnvironment::ScriptingEnvironment(const char * fileName) {
         //open utility libraries string library;
         luaL_openlibs(myLuaState);
 
+        luaAddScriptFolderToLoadPath( myLuaState, fileName );
+
         // Add our function to the state's global scope
         luabind::module(myLuaState) [
                                      luabind::def("print", LUA_print<std::string>),
@@ -51,15 +45,7 @@ ScriptingEnvironment::ScriptingEnvironment(const char * fileName) {
                                      luabind::def("durationIsValid", durationIsValid),
                                      luabind::def("parseDuration", parseDuration)
         ];
-//#pragma omp critical
-//        {
-//            if(0 != luaL_dostring(
-//                    myLuaState,
-//                    "print('Initializing LUA engine')\n"
-//            )) {
-//                ERR(lua_tostring(myLuaState,-1)<< " occured in scripting block");
-//            }
-//        }
+
         luabind::module(myLuaState) [
                                      luabind::class_<HashTable<std::string, std::string> >("keyVals")
                                      .def("Add", &HashTable<std::string, std::string>::Add)
@@ -79,32 +65,32 @@ ScriptingEnvironment::ScriptingEnvironment(const char * fileName) {
                                      ];
 
         luabind::module(myLuaState) [
-                                     luabind::class_<_Way>("Way")
+                                     luabind::class_<ExtractionWay>("Way")
                                      .def(luabind::constructor<>())
-                                     .def_readwrite("name", &_Way::name)
-                                     .def_readwrite("speed", &_Way::speed)
-                                     .def_readwrite("type", &_Way::type)
-                                     .def_readwrite("access", &_Way::access)
-                                     .def_readwrite("roundabout", &_Way::roundabout)
-                                     .def_readwrite("is_duration_set", &_Way::isDurationSet)
-                                     .def_readwrite("is_access_restricted", &_Way::isAccessRestricted)
-                                     .def_readwrite("ignore_in_grid", &_Way::ignoreInGrid)
-                                     .def_readwrite("tags", &_Way::keyVals)
-                                     .def_readwrite("direction", &_Way::direction)
+                                     .def_readwrite("name", &ExtractionWay::name)
+                                     .def_readwrite("speed", &ExtractionWay::speed)
+                                     .def_readwrite("backward_speed", &ExtractionWay::backward_speed)
+                                     .def_readwrite("duration", &ExtractionWay::duration)
+                                     .def_readwrite("type", &ExtractionWay::type)
+                                     .def_readwrite("access", &ExtractionWay::access)
+                                     .def_readwrite("roundabout", &ExtractionWay::roundabout)
+                                     .def_readwrite("is_access_restricted", &ExtractionWay::isAccessRestricted)
+                                     .def_readwrite("ignore_in_grid", &ExtractionWay::ignoreInGrid)
+                                     .def_readwrite("tags", &ExtractionWay::keyVals)
+                                     .def_readwrite("direction", &ExtractionWay::direction)
                                      .enum_("constants")
-                                     [
-                                      luabind::value("notSure", 0),
-                                      luabind::value("oneway", 1),
-                                      luabind::value("bidirectional", 2),
-                                      luabind::value("opposite", 3)
-        ]
-        ];
+										 [
+										  luabind::value("notSure", 0),
+										  luabind::value("oneway", 1),
+										  luabind::value("bidirectional", 2),
+										  luabind::value("opposite", 3)
+										 ]
+        							 ];
+        luabind::module(myLuaState) [
+                                     luabind::class_<std::vector<std::string> >("vector")
+                                     .def("Add", &std::vector<std::string>::push_back)
+                                     ];
 
-        // Now call our function in a lua script
-//#pragma omp critical
-//        {
-//            INFO("Parsing speedprofile from " << fileName );
-//        }
         if(0 != luaL_dofile(myLuaState, fileName) ) {
             ERR(lua_tostring(myLuaState,-1)<< " occured in scripting block");
         }

Extractor/ScriptingEnvironment.h

@@ -30,9 +30,11 @@ extern "C" {
 
 #include "ExtractionHelperFunctions.h"
 #include "ExtractorStructs.h"
-#include "LuaUtil.h"
 
+#include "../typedefs.h"
 #include "../DataStructures/ImportNode.h"
+#include "../Util/LuaUtil.h"
+#include "../Util/OpenMPWrapper.h"
 
 class ScriptingEnvironment {
 public:

Extractor/XMLParser.cpp

@@ -0,0 +1,276 @@
+/*
+ open source routing machine
+ Copyright (C) Dennis Luxen, others 2010
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU AFFERO General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ or see http://www.gnu.org/licenses/agpl.txt.
+ */
+
+#include <boost/ref.hpp>
+
+#include "XMLParser.h"
+
+#include "ExtractorStructs.h"
+#include "../DataStructures/HashTable.h"
+#include "../DataStructures/InputReaderFactory.h"
+
+
+XMLParser::XMLParser(const char * filename, ExtractorCallbacks* ec, ScriptingEnvironment& se) : BaseParser(ec, se) {
+	WARN("Parsing plain .osm/.osm.bz2 is deprecated. Switch to .pbf");
+	inputReader = inputReaderFactory(filename);
+}
+
+bool XMLParser::ReadHeader() {
+	return (xmlTextReaderRead( inputReader ) == 1);
+}
+bool XMLParser::Parse() {
+	while ( xmlTextReaderRead( inputReader ) == 1 ) {
+		const int type = xmlTextReaderNodeType( inputReader );
+
+		//1 is Element
+		if ( type != 1 ) {
+			continue;
+		}
+		
+		xmlChar* currentName = xmlTextReaderName( inputReader );
+		if ( currentName == NULL ) {
+			continue;
+		}
+		
+		if ( xmlStrEqual( currentName, ( const xmlChar* ) "node" ) == 1 ) {
+			ImportNode n = _ReadXMLNode();
+			ParseNodeInLua( n, luaState );
+			extractor_callbacks->nodeFunction(n);
+//			if(!extractor_callbacks->nodeFunction(n))
+//				std::cerr << "[XMLParser] dense node not parsed" << std::endl;
+		}
+
+		if ( xmlStrEqual( currentName, ( const xmlChar* ) "way" ) == 1 ) {
+			ExtractionWay way = _ReadXMLWay( );
+			ParseWayInLua( way, luaState );
+			extractor_callbacks->wayFunction(way);
+//			if(!extractor_callbacks->wayFunction(way))
+//				std::cerr << "[PBFParser] way not parsed" << std::endl;
+		}
+		if( use_turn_restrictions ) {
+			if ( xmlStrEqual( currentName, ( const xmlChar* ) "relation" ) == 1 ) {
+				_RawRestrictionContainer r = _ReadXMLRestriction();
+				if(r.fromWay != UINT_MAX) {
+					if(!extractor_callbacks->restrictionFunction(r)) {
+						std::cerr << "[XMLParser] restriction not parsed" << std::endl;
+					}
+				}
+			}
+		}
+		xmlFree( currentName );
+	}
+	return true;
+}
+
+_RawRestrictionContainer XMLParser::_ReadXMLRestriction() {
+    _RawRestrictionContainer restriction;
+    std::string except_tag_string;
+
+	if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
+		const int depth = xmlTextReaderDepth( inputReader );while ( xmlTextReaderRead( inputReader ) == 1 ) {
+			const int childType = xmlTextReaderNodeType( inputReader );
+			if ( childType != 1 && childType != 15 ) {
+				continue;
+			}
+			const int childDepth = xmlTextReaderDepth( inputReader );
+			xmlChar* childName = xmlTextReaderName( inputReader );
+			if ( childName == NULL ) {
+				continue;
+			}
+			if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "relation" ) == 1 ) {
+				xmlFree( childName );
+				break;
+			}
+			if ( childType != 1 ) {
+				xmlFree( childName );
+				continue;
+			}
+
+			if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
+				xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
+				xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
+				if ( k != NULL && value != NULL ) {
+					if(xmlStrEqual(k, ( const xmlChar* ) "restriction" )){
+						if(0 == std::string((const char *) value).find("only_")) {
+							restriction.restriction.flags.isOnly = true;
+						}
+					}
+					if ( xmlStrEqual(k, (const xmlChar *) "except") ) {
+						except_tag_string = (const char*) value;
+					}
+				}
+
+				if ( k != NULL ) {
+					xmlFree( k );
+				}
+				if ( value != NULL ) {
+					xmlFree( value );
+				}
+			} else if ( xmlStrEqual( childName, ( const xmlChar* ) "member" ) == 1 ) {
+				xmlChar* ref = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "ref" );
+				if ( ref != NULL ) {
+					xmlChar * role = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "role" );
+					xmlChar * type = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "type" );
+
+					if(xmlStrEqual(role, (const xmlChar *) "to") && xmlStrEqual(type, (const xmlChar *) "way")) {
+						restriction.toWay = atoi((const char*) ref);
+					}
+					if(xmlStrEqual(role, (const xmlChar *) "from") && xmlStrEqual(type, (const xmlChar *) "way")) {
+						restriction.fromWay = atoi((const char*) ref);
+					}
+					if(xmlStrEqual(role, (const xmlChar *) "via") && xmlStrEqual(type, (const xmlChar *) "node")) {
+						restriction.restriction.viaNode = atoi((const char*) ref);
+					}
+
+					if(NULL != type) {
+						xmlFree( type );
+					}
+					if(NULL != role) {
+						xmlFree( role );
+					}
+					if(NULL != ref) {
+						xmlFree( ref );
+					}
+				}
+			}
+			xmlFree( childName );
+		}
+	}
+
+	if( ShouldIgnoreRestriction(except_tag_string) ) {
+		restriction.fromWay = UINT_MAX;				 //workaround to ignore the restriction
+	}
+	return restriction;
+}
+
+ExtractionWay XMLParser::_ReadXMLWay() {
+	ExtractionWay way;
+	if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
+		const int depth = xmlTextReaderDepth( inputReader );
+		while ( xmlTextReaderRead( inputReader ) == 1 ) {
+			const int childType = xmlTextReaderNodeType( inputReader );
+			if ( childType != 1 && childType != 15 ) {
+				continue;
+			}
+			const int childDepth = xmlTextReaderDepth( inputReader );
+			xmlChar* childName = xmlTextReaderName( inputReader );
+			if ( childName == NULL ) {
+				continue;
+			}
+
+			if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "way" ) == 1 ) {
+				xmlChar* id = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" );
+				way.id = atoi((char*)id);
+				xmlFree(id);
+				xmlFree( childName );
+				break;
+			}
+			if ( childType != 1 ) {
+				xmlFree( childName );
+				continue;
+			}
+
+			if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
+				xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
+				xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
+				//				cout << "->k=" << k << ", v=" << value << endl;
+				if ( k != NULL && value != NULL ) {
+					way.keyVals.Add(std::string( (char *) k ), std::string( (char *) value));
+				}
+				if ( k != NULL ) {
+					xmlFree( k );
+				}
+				if ( value != NULL ) {
+					xmlFree( value );
+				}
+			} else if ( xmlStrEqual( childName, ( const xmlChar* ) "nd" ) == 1 ) {
+				xmlChar* ref = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "ref" );
+				if ( ref != NULL ) {
+					way.path.push_back( atoi(( const char* ) ref ) );
+					xmlFree( ref );
+				}
+			}
+			xmlFree( childName );
+		}
+	}
+	return way;
+}
+
+ImportNode XMLParser::_ReadXMLNode() {
+	ImportNode node;
+
+	xmlChar* attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "lat" );
+	if ( attribute != NULL ) {
+		node.lat =  static_cast<NodeID>(100000.*atof(( const char* ) attribute ) );
+		xmlFree( attribute );
+	}
+	attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "lon" );
+	if ( attribute != NULL ) {
+		node.lon =  static_cast<NodeID>(100000.*atof(( const char* ) attribute ));
+		xmlFree( attribute );
+	}
+	attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" );
+	if ( attribute != NULL ) {
+		node.id =  atoi(( const char* ) attribute );
+		xmlFree( attribute );
+	}
+
+	if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
+		const int depth = xmlTextReaderDepth( inputReader );
+		while ( xmlTextReaderRead( inputReader ) == 1 ) {
+			const int childType = xmlTextReaderNodeType( inputReader );
+			// 1 = Element, 15 = EndElement
+			if ( childType != 1 && childType != 15 ) {
+				continue;
+			}
+			const int childDepth = xmlTextReaderDepth( inputReader );
+			xmlChar* childName = xmlTextReaderName( inputReader );
+			if ( childName == NULL ) {
+				continue;
+			}
+
+			if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "node" ) == 1 ) {
+				xmlFree( childName );
+				break;
+			}
+			if ( childType != 1 ) {
+				xmlFree( childName );
+				continue;
+			}
+
+			if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
+				xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
+				xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
+				if ( k != NULL && value != NULL ) {
+					node.keyVals.Add(std::string( reinterpret_cast<char*>(k) ), std::string( reinterpret_cast<char*>(value)));
+				}
+				if ( k != NULL ) {
+					xmlFree( k );
+				}
+				if ( value != NULL ) {
+					xmlFree( value );
+				}
+			}
+
+			xmlFree( childName );
+		}
+	}
+	return node;
+}

Extractor/XMLParser.h

@@ -1,308 +1,42 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
+ open source routing machine
+ Copyright (C) Dennis Luxen, others 2010
+ 
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU AFFERO General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ any later version.
+ 
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU Affero General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ or see http://www.gnu.org/licenses/agpl.txt.
  */
 
 #ifndef XMLPARSER_H_
 #define XMLPARSER_H_
 
-#include <boost/ref.hpp>
 #include <libxml/xmlreader.h>
 
 #include "../typedefs.h"
 #include "BaseParser.h"
-#include "ExtractorStructs.h"
-#include "ExtractorCallbacks.h"
-#include "ScriptingEnvironment.h"
-#include "../DataStructures/HashTable.h"
-#include "../DataStructures/InputReaderFactory.h"
 
-class XMLParser : public BaseParser<ExtractorCallbacks, _Node, _RawRestrictionContainer, _Way> {
+class XMLParser : public BaseParser {
 public:
-    XMLParser(const char * filename) : externalMemory(NULL), myLuaState(NULL){
-        WARN("Parsing plain .osm/.osm.bz2 is deprecated. Switch to .pbf");
-        inputReader = inputReaderFactory(filename);
-    }
-    virtual ~XMLParser() {}
-
-    void RegisterCallbacks(ExtractorCallbacks * em) {
-        externalMemory = em;
-    }
-
-    void RegisterScriptingEnvironment(ScriptingEnvironment & _se) {
-        myLuaState = _se.getLuaStateForThreadID(0);
-    }
-
-    bool Init() {
-        return (xmlTextReaderRead( inputReader ) == 1);
-    }
-    bool Parse() {
-        while ( xmlTextReaderRead( inputReader ) == 1 ) {
-            const int type = xmlTextReaderNodeType( inputReader );
-
-            //1 is Element
-            if ( type != 1 )
-                continue;
-
-            xmlChar* currentName = xmlTextReaderName( inputReader );
-            if ( currentName == NULL )
-                continue;
-
-            if ( xmlStrEqual( currentName, ( const xmlChar* ) "node" ) == 1 ) {
-                ImportNode n = _ReadXMLNode(  );
-                /** Pass the unpacked node to the LUA call back **/
-                try {
-                    luabind::call_function<int>(
-                            myLuaState,
-                            "node_function",
-                            boost::ref(n)
-                    );
-                    if(!externalMemory->nodeFunction(n))
-                        std::cerr << "[XMLParser] dense node not parsed" << std::endl;
-                } catch (const luabind::error &er) {
-                    cerr << er.what() << endl;
-                    lua_State* Ler=er.state();
-                    report_errors(Ler, -1);
-                } catch (std::exception & e) {
-                    ERR(e.what());
-                } catch (...) {
-                    ERR("Unknown error occurred during XML node parsing!");
-                }
-            }
-
-            if ( xmlStrEqual( currentName, ( const xmlChar* ) "way" ) == 1 ) {
-                string name;
-                _Way way = _ReadXMLWay( );
-
-                /** Pass the unpacked way to the LUA call back **/
-                try {
-                    luabind::call_function<int>(
-                            myLuaState,
-                            "way_function",
-                            boost::ref(way),
-                            way.path.size()
-                    );
-                    if(!externalMemory->wayFunction(way)) {
-                        std::cerr << "[PBFParser] way not parsed" << std::endl;
-                    }
-                } catch (const luabind::error &er) {
-                    cerr << er.what() << endl;
-                    lua_State* Ler=er.state();
-                    report_errors(Ler, -1);
-                } catch (std::exception & e) {
-                    ERR(e.what());
-                } catch (...) {
-                    ERR("Unknown error occurred during XML way parsing!");
-                }
-            }
-            if ( xmlStrEqual( currentName, ( const xmlChar* ) "relation" ) == 1 ) {
-                _RawRestrictionContainer r = _ReadXMLRestriction();
-                if(r.fromWay != UINT_MAX) {
-                    if(!externalMemory->restrictionFunction(r)) {
-                        std::cerr << "[XMLParser] restriction not parsed" << std::endl;
-                    }
-                }
-            }
-            xmlFree( currentName );
-        }
-        return true;
-    }
-
+    XMLParser(const char* filename, ExtractorCallbacks* ec, ScriptingEnvironment& se);
+    bool ReadHeader();
+    bool Parse();
+    
 private:
-    _RawRestrictionContainer _ReadXMLRestriction ( ) {
-        _RawRestrictionContainer restriction;
-
-        if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
-            const int depth = xmlTextReaderDepth( inputReader );while ( xmlTextReaderRead( inputReader ) == 1 ) {
-                const int childType = xmlTextReaderNodeType( inputReader );
-                if ( childType != 1 && childType != 15 )
-                    continue;
-                const int childDepth = xmlTextReaderDepth( inputReader );
-                xmlChar* childName = xmlTextReaderName( inputReader );
-                if ( childName == NULL )
-                    continue;
-
-                if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "relation" ) == 1 ) {
-                    xmlFree( childName );
-                    break;
-                }
-                if ( childType != 1 ) {
-                    xmlFree( childName );
-                    continue;
-                }
-
-                if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
-                    xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
-                    xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
-                    if ( k != NULL && value != NULL ) {
-                        if(xmlStrEqual(k, ( const xmlChar* ) "restriction" )){
-                            if(0 == std::string((const char *) value).find("only_"))
-                                restriction.restriction.flags.isOnly = true;
-                        }
-
-                    }
-                    if ( k != NULL )
-                        xmlFree( k );
-                    if ( value != NULL )
-                        xmlFree( value );
-                } else if ( xmlStrEqual( childName, ( const xmlChar* ) "member" ) == 1 ) {
-                    xmlChar* ref = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "ref" );
-                    if ( ref != NULL ) {
-                        xmlChar * role = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "role" );
-                        xmlChar * type = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "type" );
-                        if(xmlStrEqual(role, (const xmlChar *) "to") && xmlStrEqual(type, (const xmlChar *) "way")) {
-                            restriction.toWay = atoi((const char*) ref);
-                        }
-                        if(xmlStrEqual(role, (const xmlChar *) "from") && xmlStrEqual(type, (const xmlChar *) "way")) {
-                            restriction.fromWay = atoi((const char*) ref);
-                        }
-                        if(xmlStrEqual(role, (const xmlChar *) "via") && xmlStrEqual(type, (const xmlChar *) "node")) {
-                            restriction.restriction.viaNode = atoi((const char*) ref);
-                        }
-
-                        if(NULL != type)
-                            xmlFree( type );
-                        if(NULL != role)
-                            xmlFree( role );
-                        if(NULL != ref)
-                            xmlFree( ref );
-                    }
-                }
-                xmlFree( childName );
-            }
-        }
-        return restriction;
-    }
-
-    _Way _ReadXMLWay( ) {
-        _Way way;
-        if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
-            const int depth = xmlTextReaderDepth( inputReader );
-            while ( xmlTextReaderRead( inputReader ) == 1 ) {
-                const int childType = xmlTextReaderNodeType( inputReader );
-                if ( childType != 1 && childType != 15 )
-                    continue;
-                const int childDepth = xmlTextReaderDepth( inputReader );
-                xmlChar* childName = xmlTextReaderName( inputReader );
-                if ( childName == NULL )
-                    continue;
-
-                if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "way" ) == 1 ) {
-                    xmlChar* id = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" );
-                    way.id = atoi((char*)id);
-                    xmlFree(id);
-                    xmlFree( childName );
-                    break;
-                }
-                if ( childType != 1 ) {
-                    xmlFree( childName );
-                    continue;
-                }
-
-                if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
-                    xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
-                    xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
-                    //                cout << "->k=" << k << ", v=" << value << endl;
-                    if ( k != NULL && value != NULL ) {
-
-                        way.keyVals.Add(std::string( (char *) k ), std::string( (char *) value));
-                    }
-                    if ( k != NULL )
-                        xmlFree( k );
-                    if ( value != NULL )
-                        xmlFree( value );
-                } else if ( xmlStrEqual( childName, ( const xmlChar* ) "nd" ) == 1 ) {
-                    xmlChar* ref = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "ref" );
-                    if ( ref != NULL ) {
-                        way.path.push_back( atoi(( const char* ) ref ) );
-                        xmlFree( ref );
-                    }
-                }
-                xmlFree( childName );
-            }
-        }
-        return way;
-    }
-
-    ImportNode _ReadXMLNode( ) {
-        ImportNode node;
-
-        xmlChar* attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "lat" );
-        if ( attribute != NULL ) {
-            node.lat =  static_cast<NodeID>(100000.*atof(( const char* ) attribute ) );
-            xmlFree( attribute );
-        }
-        attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "lon" );
-        if ( attribute != NULL ) {
-            node.lon =  static_cast<NodeID>(100000.*atof(( const char* ) attribute ));
-            xmlFree( attribute );
-        }
-        attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" );
-        if ( attribute != NULL ) {
-            node.id =  atoi(( const char* ) attribute );
-            xmlFree( attribute );
-        }
-
-        if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
-            const int depth = xmlTextReaderDepth( inputReader );
-            while ( xmlTextReaderRead( inputReader ) == 1 ) {
-                const int childType = xmlTextReaderNodeType( inputReader );
-                // 1 = Element, 15 = EndElement
-                if ( childType != 1 && childType != 15 )
-                    continue;
-                const int childDepth = xmlTextReaderDepth( inputReader );
-                xmlChar* childName = xmlTextReaderName( inputReader );
-                if ( childName == NULL )
-                    continue;
-
-                if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "node" ) == 1 ) {
-                    xmlFree( childName );
-                    break;
-                }
-                if ( childType != 1 ) {
-                    xmlFree( childName );
-                    continue;
-                }
-
-                if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
-                    xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
-                    xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
-                    if ( k != NULL && value != NULL ) {
-                        node.keyVals.Add(std::string( reinterpret_cast<char*>(k) ), std::string( reinterpret_cast<char*>(value)));
-                    }
-                    if ( k != NULL )
-                        xmlFree( k );
-                    if ( value != NULL )
-                        xmlFree( value );
-                }
-
-                xmlFree( childName );
-            }
-        }
-        return node;
-    }
-    /* Input Reader */
+    _RawRestrictionContainer _ReadXMLRestriction();
+    ExtractionWay _ReadXMLWay();
+    ImportNode _ReadXMLNode();
     xmlTextReaderPtr inputReader;
-
-    //holds the callback functions and storage for our temporary data
-    ExtractorCallbacks * externalMemory;
-
-    lua_State *myLuaState;
 };
 
 #endif /* XMLPARSER_H_ */

Plugins/LocatePlugin.h

@@ -21,13 +21,13 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #ifndef LOCATEPLUGIN_H_
 #define LOCATEPLUGIN_H_
 
-#include <fstream>
-
-#include "../Server/DataStructures/QueryObjectsStorage.h"
 #include "BasePlugin.h"
 #include "RouteParameters.h"
-#include "../Util/StringUtil.h"
 #include "../DataStructures/NodeInformationHelpDesk.h"
+#include "../Server/DataStructures/QueryObjectsStorage.h"
+#include "../Util/StringUtil.h"
+
+#include <fstream>
 
 /*
  * This Plugin locates the nearest node in the road network for a given coordinate.
@@ -52,12 +52,12 @@ public:
 
         //query to helpdesk
         _Coordinate result;
-        std::string JSONParameter, tmp;
+        std::string tmp;
         //json
 
 //        JSONParameter = routeParameters.options.Find("jsonp");
         if("" != routeParameters.jsonpParameter) {
-            reply.content += JSONParameter;
+            reply.content += routeParameters.jsonpParameter;
             reply.content += "(";
         }
         reply.status = http::Reply::ok;
@@ -82,7 +82,7 @@ public:
         reply.content += ",\"transactionId\": \"OSRM Routing Engine JSON Locate (v0.3)\"";
         reply.content += ("}");
         reply.headers.resize(3);
-        if("" != JSONParameter) {
+        if("" != routeParameters.jsonpParameter) {
             reply.content += ")";
             reply.headers[1].name = "Content-Type";
             reply.headers[1].value = "text/javascript";

Plugins/NearestPlugin.h

@@ -60,7 +60,6 @@ public:
         nodeHelpDesk->FindPhantomNodeForCoordinate(routeParameters.coordinates[0], result, routeParameters.zoomLevel);
 
         std::string tmp;
-        std::string JSONParameter;
         //json
 
         if("" != routeParameters.jsonpParameter) {
@@ -93,7 +92,7 @@ public:
         reply.content += ",\"transactionId\":\"OSRM Routing Engine JSON Nearest (v0.3)\"";
         reply.content += ("}");
         reply.headers.resize(3);
-        if("" != JSONParameter) {
+        if("" != routeParameters.jsonpParameter) {
             reply.content += ")";
             reply.headers[1].name = "Content-Type";
             reply.headers[1].value = "text/javascript";

Plugins/ViaRoutePlugin.h

@@ -52,14 +52,14 @@ private:
     StaticGraph<QueryEdge::EdgeData> * graph;
     HashTable<std::string, unsigned> descriptorTable;
     std::string pluginDescriptorString;
-    SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> > * searchEngine;
+    SearchEngine * searchEnginePtr;
 public:
 
     ViaRoutePlugin(QueryObjectsStorage * objects, std::string psd = "viaroute") : names(objects->names), pluginDescriptorString(psd) {
         nodeHelpDesk = objects->nodeHelpDesk;
         graph = objects->graph;
 
-        searchEngine = new SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> >(graph, nodeHelpDesk, names);
+        searchEnginePtr = new SearchEngine(graph, nodeHelpDesk, names);
 
         descriptorTable.Set("", 0); //default descriptor
         descriptorTable.Set("json", 0);
@@ -67,7 +67,7 @@ public:
     }
 
     virtual ~ViaRoutePlugin() {
-        delete searchEngine;
+        delete searchEnginePtr;
     }
 
     std::string GetDescriptor() const { return pluginDescriptorString; }
@@ -101,7 +101,7 @@ public:
                 }
             }
 //            INFO("Brute force lookup of coordinate " << i);
-            searchEngine->FindPhantomNodeForCoordinate( rawRoute.rawViaNodeCoordinates[i], phantomNodeVector[i], routeParameters.zoomLevel);
+            searchEnginePtr->FindPhantomNodeForCoordinate( rawRoute.rawViaNodeCoordinates[i], phantomNodeVector[i], routeParameters.zoomLevel);
         }
 
         for(unsigned i = 0; i < phantomNodeVector.size()-1; ++i) {
@@ -112,10 +112,10 @@ public:
         }
         if( ( routeParameters.alternateRoute ) && (1 == rawRoute.segmentEndCoordinates.size()) ) {
 //            INFO("Checking for alternative paths");
-            searchEngine->alternativePaths(rawRoute.segmentEndCoordinates[0],  rawRoute);
+            searchEnginePtr->alternativePaths(rawRoute.segmentEndCoordinates[0],  rawRoute);
 
         } else {
-            searchEngine->shortestPath(rawRoute.segmentEndCoordinates, rawRoute);
+            searchEnginePtr->shortestPath(rawRoute.segmentEndCoordinates, rawRoute);
         }
 
 
@@ -125,7 +125,7 @@ public:
         reply.status = http::Reply::ok;
 
         //TODO: Move to member as smart pointer
-        BaseDescriptor<SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> > > * desc;
+        BaseDescriptor * desc;
         if("" != routeParameters.jsonpParameter) {
             reply.content += routeParameters.jsonpParameter;
             reply.content += "(";
@@ -140,15 +140,15 @@ public:
 
         switch(descriptorType){
         case 0:
-            desc = new JSONDescriptor<SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> > >();
+            desc = new JSONDescriptor();
 
             break;
         case 1:
-            desc = new GPXDescriptor<SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> > >();
+            desc = new GPXDescriptor();
 
             break;
         default:
-            desc = new JSONDescriptor<SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> > >();
+            desc = new JSONDescriptor();
 
             break;
         }
@@ -161,7 +161,7 @@ public:
 //        INFO("Number of segments: " << rawRoute.segmentEndCoordinates.size());
         desc->SetConfig(descriptorConfig);
 
-        desc->Run(reply, rawRoute, phantomNodes, *searchEngine);
+        desc->Run(reply, rawRoute, phantomNodes, *searchEnginePtr);
         if("" != routeParameters.jsonpParameter) {
             reply.content += ")\n";
         }

README.TXT

@@ -4,4 +4,24 @@ https://github.com/DennisOSRM/Project-OSRM/wiki
 
 or use our free and daily updated online service at
 
-http://map.project-osrm.org
+http://map.project-osrm.org
+
+When using the code in a scientific publication, please cite
+
+@inproceedings{luxen-vetter-2011,
+ author = {Luxen, Dennis and Vetter, Christian},
+ title = {Real-time routing with OpenStreetMap data},
+ booktitle = {Proceedings of the 19th ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems},
+ series = {GIS '11},
+ year = {2011},
+ isbn = {978-1-4503-1031-4},
+ location = {Chicago, Illinois},
+ pages = {513--516},
+ numpages = {4},
+ url = {http://doi.acm.org/10.1145/2093973.2094062},
+ doi = {10.1145/2093973.2094062},
+ acmid = {2094062},
+ publisher = {ACM},
+ address = {New York, NY, USA},
+} 
+

Rakefile

@@ -4,9 +4,11 @@ require 'digest/sha1'
 require 'cucumber/rake/task'
 require 'sys/proctable'
 
+BUILD_FOLDER = 'build'
 DATA_FOLDER = 'sandbox'
 PROFILE = 'bicycle'
 OSRM_PORT = 5000
+PROFILES_FOLDER = '../profiles'
 
 Cucumber::Rake::Task.new do |t|
   t.cucumber_opts = %w{--format pretty}
@@ -16,7 +18,7 @@ areas = {
   :kbh => { :country => 'denmark', :bbox => 'top=55.6972 left=12.5222 right=12.624 bottom=55.6376' },
   :frd => { :country => 'denmark', :bbox => 'top=55.7007 left=12.4765 bottom=55.6576 right=12.5698' },
   :regh => { :country => 'denmark', :bbox => 'top=56.164 left=11.792 bottom=55.403 right=12.731' },
-  :dk => { :country => 'denmark', :bbox => nil },
+  :denmark => { :country => 'denmark', :bbox => nil },
   :skaane => { :country => 'sweden', :bbox => 'top=56.55 left=12.4 bottom=55.3 right=14.6' }
 }
 
@@ -76,11 +78,13 @@ end
 
 
 desc "Rebuild and run tests."
-task :default => [:build, :cucumber]
+task :default => [:build]
 
-desc "Build using SConsstruct."
+desc "Build using CMake."
 task :build do
-  system "scons"
+  Dir.chdir BUILD_FOLDER do
+    system "make"
+  end
 end
 
 desc "Setup config files."
@@ -98,8 +102,8 @@ desc "Download OSM data."
 task :download => :setup do
   Dir.mkdir "#{DATA_FOLDER}" unless File.exist? "#{DATA_FOLDER}"
   puts "Downloading..."
-  puts "curl http://download.geofabrik.de/openstreetmap/europe/#{osm_data_country}.osm.pbf -o #{DATA_FOLDER}/#{osm_data_country}.osm.pbf"
-  raise "Error while downloading data." unless system "curl http://download.geofabrik.de/openstreetmap/europe/#{osm_data_country}.osm.pbf -o #{DATA_FOLDER}/#{osm_data_country}.osm.pbf"
+  puts "curl http://download.geofabrik.de/europe/#{osm_data_country}-latest.osm.pbf -o #{DATA_FOLDER}/#{osm_data_country}.osm.pbf"
+  raise "Error while downloading data." unless system "curl http://download.geofabrik.de/europe/#{osm_data_country}-latest.osm.pbf -o #{DATA_FOLDER}/#{osm_data_country}.osm.pbf"
   if osm_data_area_bbox
     puts "Cropping and converting to protobuffer..."
     raise "Error while cropping data." unless system "osmosis --read-pbf file=#{DATA_FOLDER}/#{osm_data_country}.osm.pbf --bounding-box #{osm_data_area_bbox} --write-pbf file=#{DATA_FOLDER}/#{osm_data_area_name}.osm.pbf omitmetadata=true"
@@ -116,13 +120,27 @@ end
 desc "Reprocess OSM data."
 task :process => :setup do
   Dir.chdir DATA_FOLDER do
-    raise "Error while extracting data." unless system "../osrm-extract #{osm_data_area_name}.osm.pbf ../profiles/#{PROFILE}.lua"
+    raise "Error while extracting data." unless system "../#{BUILD_FOLDER}/osrm-extract #{osm_data_area_name}.osm.pbf #{PROFILES_FOLDER}/#{PROFILE}.lua"
     puts
-    raise "Error while preparing data." unless system "../osrm-prepare #{osm_data_area_name}.osrm #{osm_data_area_name}.osrm.restrictions ../profiles/#{PROFILE}.lua"
+    raise "Error while preparing data." unless system "../#{BUILD_FOLDER}/osrm-prepare #{osm_data_area_name}.osrm #{osm_data_area_name}.osrm.restrictions #{PROFILES_FOLDER}/#{PROFILE}.lua"
     puts
   end
 end
 
+desc "Extract OSM data."
+task :extract => :setup do
+  Dir.chdir DATA_FOLDER do
+    raise "Error while extracting data." unless system "../#{BUILD_FOLDER}/osrm-extract #{osm_data_area_name}.osm.pbf ../profiles/#{PROFILE}.lua"
+  end
+end
+
+desc "Prepare OSM data."
+task :prepare => :setup do
+  Dir.chdir DATA_FOLDER do
+    raise "Error while preparing data." unless system "../#{BUILD_FOLDER}/osrm-prepare #{osm_data_area_name}.osrm #{osm_data_area_name}.osrm.restrictions ../profiles/#{PROFILE}.lua"
+  end
+end
+
 desc "Delete preprocessing files."
 task :clean do
   File.delete *Dir.glob("#{DATA_FOLDER}/*.osrm")
@@ -139,7 +157,7 @@ desc "Run the routing server in the terminal. Press Ctrl-C to stop."
 task :run => :setup do
   Dir.chdir DATA_FOLDER do
     write_server_ini osm_data_area_name
-    system "../osrm-routed"
+    system "../#{BUILD_FOLDER}/osrm-routed"
   end
 end
 
@@ -148,7 +166,7 @@ task :up => :setup do
   Dir.chdir DATA_FOLDER do
     abort("Already up.") if up?
     write_server_ini osm_data_area_name
-    pipe = IO.popen('../osrm-routed 1>>osrm-routed.log 2>>osrm-routed.log')
+    pipe = IO.popen("../#{BUILD_FOLDER}/osrm-routed 1>>osrm-routed.log 2>>osrm-routed.log")
     timeout = 5
     (timeout*10).times do
       begin

RoutingAlgorithms/AlternativePathRouting.h

@@ -21,23 +21,25 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #ifndef ALTERNATIVEROUTES_H_
 #define ALTERNATIVEROUTES_H_
 
+#include <boost/unordered_map.hpp>
+#include <vector>
 #include <cmath>
 
 #include "BasicRoutingInterface.h"
 
-const double VIAPATH_ALPHA   = 0.25;
-const double VIAPATH_EPSILON = 0.25;
-const double VIAPATH_GAMMA   = 0.80;
+const double VIAPATH_ALPHA   = 0.15;
+const double VIAPATH_EPSILON = 0.10; //alternative at most 15% longer
+const double VIAPATH_GAMMA   = 0.75; //alternative shares at most 75% with the shortest.
 
 template<class QueryDataT>
-class AlternativeRouting : private BasicRoutingInterface<QueryDataT>{
+class AlternativeRouting : private BasicRoutingInterface<QueryDataT> {
     typedef BasicRoutingInterface<QueryDataT> super;
-    typedef std::pair<NodeID, int> PreselectedNode;
-    typedef typename QueryDataT::HeapPtr HeapPtr;
-    typedef std::pair<NodeID, NodeID> UnpackEdge;
+    typedef typename QueryDataT::Graph SearchGraph;
+    typedef typename QueryDataT::QueryHeap QueryHeap;
+    typedef std::pair<NodeID, NodeID> SearchSpaceEdge;
 
     struct RankedCandidateNode {
-        RankedCandidateNode(NodeID n, int l, int s) : node(n), length(l), sharing(s) {}
+        RankedCandidateNode(const NodeID n, const int l, const int s) : node(n), length(l), sharing(s) {}
         NodeID node;
         int length;
         int sharing;
@@ -45,9 +47,12 @@ class AlternativeRouting : private BasicRoutingInterface<QueryDataT>{
             return (2*length + sharing) < (2*other.length + other.sharing);
         }
     };
+
+    const SearchGraph * search_graph;
+
 public:
 
-    AlternativeRouting(QueryDataT & qd) : super(qd) { }
+    AlternativeRouting(QueryDataT & qd) : super(qd), search_graph(qd.graph) { }
 
     ~AlternativeRouting() {}
 
@@ -59,81 +64,115 @@ public:
 
         std::vector<NodeID> alternativePath;
         std::vector<NodeID> viaNodeCandidates;
-        std::vector <NodeID> packedShortestPath;
-        std::vector<PreselectedNode> nodesThatPassPreselection;
+        std::vector<SearchSpaceEdge> forward_search_space;
+        std::vector<SearchSpaceEdge> reverse_search_space;
 
-        HeapPtr & forwardHeap = super::_queryData.forwardHeap;
-        HeapPtr & backwardHeap = super::_queryData.backwardHeap;
-        HeapPtr & forwardHeap2 = super::_queryData.forwardHeap2;
-        HeapPtr & backwardHeap2 = super::_queryData.backwardHeap2;
-
-        //Initialize Queues
+        //Initialize Queues, semi-expensive because access to TSS invokes a system call
         super::_queryData.InitializeOrClearFirstThreadLocalStorage();
-        int _upperBound = INT_MAX;
-        NodeID middle = UINT_MAX;
-        forwardHeap->Insert(phantomNodePair.startPhantom.edgeBasedNode, -phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
+        super::_queryData.InitializeOrClearSecondThreadLocalStorage();
+        super::_queryData.InitializeOrClearThirdThreadLocalStorage();
+
+        QueryHeap & forward_heap1 = *(super::_queryData.forwardHeap);
+        QueryHeap & reverse_heap1 = *(super::_queryData.backwardHeap);
+        QueryHeap & forward_heap2 = *(super::_queryData.forwardHeap2);
+        QueryHeap & reverse_heap2 = *(super::_queryData.backwardHeap2);
+
+        int upper_bound_to_shortest_path_distance = INT_MAX;
+        NodeID middle_node = UINT_MAX;
+        forward_heap1.Insert(phantomNodePair.startPhantom.edgeBasedNode, -phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
         if(phantomNodePair.startPhantom.isBidirected() ) {
-            forwardHeap->Insert(phantomNodePair.startPhantom.edgeBasedNode+1, -phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
+            forward_heap1.Insert(phantomNodePair.startPhantom.edgeBasedNode+1, -phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
         }
-        backwardHeap->Insert(phantomNodePair.targetPhantom.edgeBasedNode, phantomNodePair.targetPhantom.weight1, phantomNodePair.targetPhantom.edgeBasedNode);
+        reverse_heap1.Insert(phantomNodePair.targetPhantom.edgeBasedNode, phantomNodePair.targetPhantom.weight1, phantomNodePair.targetPhantom.edgeBasedNode);
         if(phantomNodePair.targetPhantom.isBidirected() ) {
-            backwardHeap->Insert(phantomNodePair.targetPhantom.edgeBasedNode+1, phantomNodePair.targetPhantom.weight2, phantomNodePair.targetPhantom.edgeBasedNode+1);
+        	reverse_heap1.Insert(phantomNodePair.targetPhantom.edgeBasedNode+1, phantomNodePair.targetPhantom.weight2, phantomNodePair.targetPhantom.edgeBasedNode+1);
         }
 
-        const int offset = (phantomNodePair.startPhantom.isBidirected() ? std::max(phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.weight2) : phantomNodePair.startPhantom.weight1)
-            + (phantomNodePair.targetPhantom.isBidirected() ? std::max(phantomNodePair.targetPhantom.weight1, phantomNodePair.targetPhantom.weight2) : phantomNodePair.targetPhantom.weight1);
+        const int forward_offset = phantomNodePair.startPhantom.weight1 + (phantomNodePair.startPhantom.isBidirected() ? phantomNodePair.startPhantom.weight2 : 0);
+        const int reverse_offset = phantomNodePair.targetPhantom.weight1 + (phantomNodePair.targetPhantom.isBidirected() ? phantomNodePair.targetPhantom.weight2 : 0);
 
         //exploration dijkstra from nodes s and t until deletemin/(1+epsilon) > _lengthOfShortestPath
-        while(forwardHeap->Size() + backwardHeap->Size() > 0){
-            if(forwardHeap->Size() > 0){
-                AlternativeRoutingStep(forwardHeap, backwardHeap, &middle, &_upperBound, 2*offset, true, viaNodeCandidates);
+        while(0 < (forward_heap1.Size() + reverse_heap1.Size())){
+            if(0 < forward_heap1.Size()){
+                AlternativeRoutingStep<true >(forward_heap1, reverse_heap1, &middle_node, &upper_bound_to_shortest_path_distance, viaNodeCandidates, forward_search_space, forward_offset);
             }
-            if(backwardHeap->Size() > 0){
-                AlternativeRoutingStep(backwardHeap, forwardHeap, &middle, &_upperBound, 2*offset, false, viaNodeCandidates);
+            if(0 < reverse_heap1.Size()){
+                AlternativeRoutingStep<false>(reverse_heap1, forward_heap1, &middle_node, &upper_bound_to_shortest_path_distance, viaNodeCandidates, reverse_search_space, reverse_offset);
             }
         }
-        std::sort(viaNodeCandidates.begin(), viaNodeCandidates.end());
-        int size = std::unique(viaNodeCandidates.begin(), viaNodeCandidates.end())- viaNodeCandidates.begin();
-        viaNodeCandidates.resize(size);
+        sort_unique_resize(viaNodeCandidates);
 
-        //save (packed) shortest path of shortest path and keep it for later use.
-        //we need it during the checks and dont want to recompute it always
-        super::RetrievePackedPathFromHeap(forwardHeap, backwardHeap, middle, packedShortestPath);
+        std::vector<NodeID> packed_forward_path;
+        std::vector<NodeID> packed_reverse_path;
 
-        //ch-pruning of via nodes in both search spaces
+        super::RetrievePackedPathFromSingleHeap(forward_heap1, middle_node, packed_forward_path);
+        super::RetrievePackedPathFromSingleHeap(reverse_heap1, middle_node, packed_reverse_path);
+        boost::unordered_map<NodeID, int> approximated_forward_sharing;
+        boost::unordered_map<NodeID, int> approximated_reverse_sharing;
+
+        unsigned index_into_forward_path = 0;
+        //sweep over search space, compute forward sharing for each current edge (u,v)
+        BOOST_FOREACH(const SearchSpaceEdge & current_edge, forward_search_space) {
+        	const NodeID u = current_edge.first;
+        	const NodeID v = current_edge.second;
+        	if(packed_forward_path.size() < index_into_forward_path && current_edge == forward_search_space[index_into_forward_path]) {
+        		//current_edge is on shortest path => sharing(u):=queue.GetKey(u);
+        		++index_into_forward_path;
+        		approximated_forward_sharing[v] = forward_heap1.GetKey(u);
+        	} else {
+        		//sharing (s) = sharing (t)
+        		approximated_forward_sharing[v] = approximated_forward_sharing[u];
+        	}
+        }
+
+        unsigned index_into_reverse_path = 0;
+        //sweep over search space, compute backward sharing
+        BOOST_FOREACH(const SearchSpaceEdge & current_edge, reverse_search_space) {
+        	const NodeID u = current_edge.first;
+        	const NodeID v = current_edge.second;
+        	if(packed_reverse_path.size() < index_into_reverse_path && current_edge == reverse_search_space[index_into_reverse_path]) {
+        		//current_edge is on shortest path => sharing(u):=queue.GetKey(u);
+        		++index_into_reverse_path;
+        		approximated_reverse_sharing[v] = reverse_heap1.GetKey(u);
+        	} else {
+        		//sharing (s) = sharing (t)
+        		approximated_reverse_sharing[v] = approximated_reverse_sharing[u];
+        	}
+        }
+        std::vector<NodeID> nodes_that_passed_preselection;
         BOOST_FOREACH(const NodeID node, viaNodeCandidates) {
-            if(node == middle) //subpath optimality tells us that this case is just the shortest path
-                continue;
+            int approximated_sharing = approximated_forward_sharing[node] + approximated_reverse_sharing[node];
+            int approximated_length = forward_heap1.GetKey(node)+reverse_heap1.GetKey(node);
+            bool lengthPassed = (approximated_length < upper_bound_to_shortest_path_distance*(1+VIAPATH_EPSILON));
+            bool sharingPassed = (approximated_sharing <= upper_bound_to_shortest_path_distance*VIAPATH_GAMMA);
+            bool stretchPassed = approximated_length - approximated_sharing < (1.+VIAPATH_EPSILON)*(upper_bound_to_shortest_path_distance-approximated_sharing);
 
-            int sharing = approximateAmountOfSharing(node, forwardHeap, backwardHeap, packedShortestPath);
-            int length1 = forwardHeap->GetKey(node);
-            int length2 = backwardHeap->GetKey(node);
-            bool lengthPassed = (length1+length2 < _upperBound*(1+VIAPATH_EPSILON));
-            bool sharingPassed = (sharing <= _upperBound*VIAPATH_GAMMA);
-            bool stretchPassed = length1+length2 - sharing < (1.+VIAPATH_EPSILON)*(_upperBound-sharing);
-
-            if(lengthPassed && sharingPassed && stretchPassed)
-                nodesThatPassPreselection.push_back(std::make_pair(node, length1+length2));
+            if(lengthPassed && sharingPassed && stretchPassed) {
+                nodes_that_passed_preselection.push_back(node);
+            }
         }
 
+        std::vector<NodeID> & packedShortestPath = packed_forward_path;
+        std::reverse(packedShortestPath.begin(), packedShortestPath.end());
+        packedShortestPath.push_back(middle_node);
+        packedShortestPath.insert(packedShortestPath.end(),packed_reverse_path.begin(), packed_reverse_path.end());
         std::vector<RankedCandidateNode > rankedCandidates;
 
         //prioritizing via nodes for deep inspection
-        BOOST_FOREACH(const PreselectedNode node, nodesThatPassPreselection) {
+        BOOST_FOREACH(const NodeID node, nodes_that_passed_preselection) {
             int lengthOfViaPath = 0, sharingOfViaPath = 0;
-
-            computeLengthAndSharingOfViaPath(node, &lengthOfViaPath, &sharingOfViaPath, offset, packedShortestPath);
-            if(sharingOfViaPath <= VIAPATH_GAMMA*_upperBound)
-                rankedCandidates.push_back(RankedCandidateNode(node.first, lengthOfViaPath, sharingOfViaPath));
+            computeLengthAndSharingOfViaPath(node, &lengthOfViaPath, &sharingOfViaPath, forward_offset+reverse_offset, packedShortestPath);
+            if(sharingOfViaPath <= upper_bound_to_shortest_path_distance*VIAPATH_GAMMA) {
+                rankedCandidates.push_back(RankedCandidateNode(node, lengthOfViaPath, sharingOfViaPath));
+            }
         }
-
         std::sort(rankedCandidates.begin(), rankedCandidates.end());
 
         NodeID selectedViaNode = UINT_MAX;
         int lengthOfViaPath = INT_MAX;
         NodeID s_v_middle = UINT_MAX, v_t_middle = UINT_MAX;
-        BOOST_FOREACH(const RankedCandidateNode candidate, rankedCandidates){
-            if(viaNodeCandidatePasses_T_Test(forwardHeap, backwardHeap, forwardHeap2, backwardHeap2, candidate, offset, _upperBound, &lengthOfViaPath, &s_v_middle, &v_t_middle)) {
+        BOOST_FOREACH(const RankedCandidateNode & candidate, rankedCandidates){
+            if(viaNodeCandidatePasses_T_Test(forward_heap1, reverse_heap1, forward_heap2, reverse_heap2, candidate, forward_offset+reverse_offset, upper_bound_to_shortest_path_distance, &lengthOfViaPath, &s_v_middle, &v_t_middle)) {
                 // select first admissable
                 selectedViaNode = candidate.node;
                 break;
@@ -141,15 +180,15 @@ public:
         }
 
         //Unpack shortest path and alternative, if they exist
-        if(INT_MAX != _upperBound) {
+        if(INT_MAX != upper_bound_to_shortest_path_distance) {
             super::UnpackPath(packedShortestPath, rawRouteData.computedShortestPath);
-            rawRouteData.lengthOfShortestPath = _upperBound;
+            rawRouteData.lengthOfShortestPath = upper_bound_to_shortest_path_distance;
         } else {
             rawRouteData.lengthOfShortestPath = INT_MAX;
         }
 
         if(selectedViaNode != UINT_MAX) {
-            retrievePackedViaPath(forwardHeap, backwardHeap, forwardHeap2, backwardHeap2, s_v_middle, v_t_middle, rawRouteData.computedAlternativePath);
+            retrievePackedViaPath(forward_heap1, reverse_heap1, forward_heap2, reverse_heap2, s_v_middle, v_t_middle, rawRouteData.computedAlternativePath);
             rawRouteData.lengthOfAlternativePath = lengthOfViaPath;
         } else {
             rawRouteData.lengthOfAlternativePath = INT_MAX;
@@ -158,7 +197,7 @@ public:
 
 private:
     //unpack <s,..,v,..,t> by exploring search spaces from v
-    inline void retrievePackedViaPath(const HeapPtr & _forwardHeap1, const HeapPtr & _backwardHeap1, const HeapPtr & _forwardHeap2, const HeapPtr & _backwardHeap2,
+    inline void retrievePackedViaPath(QueryHeap & _forwardHeap1, QueryHeap & _backwardHeap1, QueryHeap & _forwardHeap2, QueryHeap & _backwardHeap2,
             const NodeID s_v_middle, const NodeID v_t_middle, std::vector<_PathData> & unpackedPath) {
         //unpack [s,v)
         std::vector<NodeID> packed_s_v_path, packed_v_t_path;
@@ -170,16 +209,16 @@ private:
         super::UnpackPath(packed_s_v_path, unpackedPath);
     }
 
-    inline void computeLengthAndSharingOfViaPath(const PreselectedNode& node, int *lengthOfViaPath, int *sharingOfViaPath,
-            const int offset, const std::vector<NodeID> & packedShortestPath) {
+    inline void computeLengthAndSharingOfViaPath(const NodeID via_node, int *real_length_of_via_path, int *sharing_of_via_path,
+            const int offset, const std::vector<NodeID> & packed_shortest_path) {
         //compute and unpack <s,..,v> and <v,..,t> by exploring search spaces from v and intersecting against queues
         //only half-searches have to be done at this stage
         super::_queryData.InitializeOrClearSecondThreadLocalStorage();
 
-        HeapPtr & existingForwardHeap  = super::_queryData.forwardHeap;
-        HeapPtr & existingBackwardHeap = super::_queryData.backwardHeap;
-        HeapPtr & newForwardHeap       = super::_queryData.forwardHeap2;
-        HeapPtr & newBackwardHeap      = super::_queryData.backwardHeap2;
+        QueryHeap & existingForwardHeap  = *super::_queryData.forwardHeap;
+        QueryHeap & existingBackwardHeap = *super::_queryData.backwardHeap;
+        QueryHeap & newForwardHeap       = *super::_queryData.forwardHeap2;
+        QueryHeap & newBackwardHeap      = *super::_queryData.backwardHeap2;
 
         std::vector < NodeID > packed_s_v_path;
         std::vector < NodeID > packed_v_t_path;
@@ -189,18 +228,18 @@ private:
 
         NodeID s_v_middle = UINT_MAX;
         int upperBoundFor_s_v_Path = INT_MAX;//compute path <s,..,v> by reusing forward search from s
-        newBackwardHeap->Insert(node.first, 0, node.first);
-        while (newBackwardHeap->Size() > 0) {
+        newBackwardHeap.Insert(via_node, 0, via_node);
+        while (0 < newBackwardHeap.Size()) {
             super::RoutingStep(newBackwardHeap, existingForwardHeap, &s_v_middle, &upperBoundFor_s_v_Path, 2 * offset, false);
         }
         //compute path <v,..,t> by reusing backward search from node t
         NodeID v_t_middle = UINT_MAX;
         int upperBoundFor_v_t_Path = INT_MAX;
-        newForwardHeap->Insert(node.first, 0, node.first);
-        while (newForwardHeap->Size() > 0) {
+        newForwardHeap.Insert(via_node, 0, via_node);
+        while (0 < newForwardHeap.Size() ) {
             super::RoutingStep(newForwardHeap, existingBackwardHeap, &v_t_middle, &upperBoundFor_v_t_Path, 2 * offset, true);
         }
-        *lengthOfViaPath = upperBoundFor_s_v_Path + upperBoundFor_v_t_Path;
+        *real_length_of_via_path = upperBoundFor_s_v_Path + upperBoundFor_v_t_Path;
 
         if(UINT_MAX == s_v_middle || UINT_MAX == v_t_middle)
             return;
@@ -211,35 +250,35 @@ private:
 
         //partial unpacking, compute sharing
         //First partially unpack s-->v until paths deviate, note length of common path.
-        for (unsigned i = 0, lengthOfPackedPath = std::min( packed_s_v_path.size(), packedShortestPath.size()) - 1; (i < lengthOfPackedPath); ++i) {
-            if (packed_s_v_path[i] == packedShortestPath[i] && packed_s_v_path[i + 1] == packedShortestPath[i + 1]) {
-                typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection(packed_s_v_path[i], packed_s_v_path[i + 1]);
-                *sharingOfViaPath += super::_queryData.graph->GetEdgeData(edgeID).distance;
+        for (unsigned i = 0, lengthOfPackedPath = std::min( packed_s_v_path.size(), packed_shortest_path.size()) - 1; (i < lengthOfPackedPath); ++i) {
+            if (packed_s_v_path[i] == packed_shortest_path[i] && packed_s_v_path[i + 1] == packed_shortest_path[i + 1]) {
+                typename SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection(packed_s_v_path[i], packed_s_v_path[i + 1]);
+                *sharing_of_via_path += search_graph->GetEdgeData(edgeID).distance;
             } else {
-                if (packed_s_v_path[i] == packedShortestPath[i]) {
+                if (packed_s_v_path[i] == packed_shortest_path[i]) {
                     super::UnpackEdge(packed_s_v_path[i], packed_s_v_path[i+1], partiallyUnpackedViaPath);
-                    super::UnpackEdge(packedShortestPath[i], packedShortestPath[i+1], partiallyUnpackedShortestPath);
+                    super::UnpackEdge(packed_shortest_path[i], packed_shortest_path[i+1], partiallyUnpackedShortestPath);
                     break;
                 }
             }
         }
         //traverse partially unpacked edge and note common prefix
         for (int i = 0, lengthOfPackedPath = std::min( partiallyUnpackedViaPath.size(), partiallyUnpackedShortestPath.size()) - 1; (i < lengthOfPackedPath) && (partiallyUnpackedViaPath[i] == partiallyUnpackedShortestPath[i] && partiallyUnpackedViaPath[i+1] == partiallyUnpackedShortestPath[i+1]); ++i) {
-            typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection(partiallyUnpackedViaPath[i], partiallyUnpackedViaPath[i+1]);
-            *sharingOfViaPath += super::_queryData.graph->GetEdgeData(edgeID).distance;
+            typename SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection(partiallyUnpackedViaPath[i], partiallyUnpackedViaPath[i+1]);
+            *sharing_of_via_path += search_graph->GetEdgeData(edgeID).distance;
         }
 
         //Second, partially unpack v-->t in reverse order until paths deviate and note lengths
         int viaPathIndex = packed_v_t_path.size() - 1;
-        int shortestPathIndex = packedShortestPath.size() - 1;
+        int shortestPathIndex = packed_shortest_path.size() - 1;
         for (; viaPathIndex > 0 && shortestPathIndex > 0; --viaPathIndex,--shortestPathIndex ) {
-            if (packed_v_t_path[viaPathIndex - 1] == packedShortestPath[shortestPathIndex - 1] && packed_v_t_path[viaPathIndex] == packedShortestPath[shortestPathIndex]) {
-                typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection( packed_v_t_path[viaPathIndex - 1], packed_v_t_path[viaPathIndex]);
-                *sharingOfViaPath += super::_queryData.graph->GetEdgeData(edgeID).distance;
+            if (packed_v_t_path[viaPathIndex - 1] == packed_shortest_path[shortestPathIndex - 1] && packed_v_t_path[viaPathIndex] == packed_shortest_path[shortestPathIndex]) {
+                typename SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection( packed_v_t_path[viaPathIndex - 1], packed_v_t_path[viaPathIndex]);
+                *sharing_of_via_path += search_graph->GetEdgeData(edgeID).distance;
             } else {
-                if (packed_v_t_path[viaPathIndex] == packedShortestPath[shortestPathIndex]) {
+                if (packed_v_t_path[viaPathIndex] == packed_shortest_path[shortestPathIndex]) {
                     super::UnpackEdge(packed_v_t_path[viaPathIndex-1], packed_v_t_path[viaPathIndex], partiallyUnpackedViaPath);
-                    super::UnpackEdge(packedShortestPath[shortestPathIndex-1] , packedShortestPath[shortestPathIndex], partiallyUnpackedShortestPath);
+                    super::UnpackEdge(packed_shortest_path[shortestPathIndex-1] , packed_shortest_path[shortestPathIndex], partiallyUnpackedShortestPath);
                     break;
                 }
             }
@@ -249,16 +288,16 @@ private:
         shortestPathIndex = partiallyUnpackedShortestPath.size() - 1;
         for (; viaPathIndex > 0 && shortestPathIndex > 0; --viaPathIndex,--shortestPathIndex) {
             if (partiallyUnpackedViaPath[viaPathIndex - 1] == partiallyUnpackedShortestPath[shortestPathIndex - 1] && partiallyUnpackedViaPath[viaPathIndex] == partiallyUnpackedShortestPath[shortestPathIndex]) {
-                typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection( partiallyUnpackedViaPath[viaPathIndex - 1], partiallyUnpackedViaPath[viaPathIndex]);
-                *sharingOfViaPath += super::_queryData.graph->GetEdgeData(edgeID).distance;
+                typename SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection( partiallyUnpackedViaPath[viaPathIndex - 1], partiallyUnpackedViaPath[viaPathIndex]);
+                *sharing_of_via_path += search_graph->GetEdgeData(edgeID).distance;
             } else {
                 break;
             }
         }
-        //finished partial unpacking spree! Amount of sharing is stored to appropriate poiner variable
+        //finished partial unpacking spree! Amount of sharing is stored to appropriate pointer variable
     }
 
-    inline int approximateAmountOfSharing(const NodeID middleNodeIDOfAlternativePath, HeapPtr & _forwardHeap, HeapPtr & _backwardHeap, const std::vector<NodeID> & packedShortestPath) {
+    inline int approximateAmountOfSharing(const NodeID middleNodeIDOfAlternativePath, QueryHeap & _forwardHeap, QueryHeap & _backwardHeap, const std::vector<NodeID> & packedShortestPath) {
         std::vector<NodeID> packedAlternativePath;
         super::RetrievePackedPathFromHeap(_forwardHeap, _backwardHeap, middleNodeIDOfAlternativePath, packedAlternativePath);
 
@@ -270,8 +309,8 @@ private:
         //compute forward sharing
         while( (packedAlternativePath[aindex] == packedShortestPath[aindex]) && (packedAlternativePath[aindex+1] == packedShortestPath[aindex+1]) ) {
             //            INFO("retrieving edge (" << packedAlternativePath[aindex] << "," << packedAlternativePath[aindex+1] << ")");
-            typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection(packedAlternativePath[aindex], packedAlternativePath[aindex+1]);
-            sharing += super::_queryData.graph->GetEdgeData(edgeID).distance;
+            typename SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection(packedAlternativePath[aindex], packedAlternativePath[aindex+1]);
+            sharing += search_graph->GetEdgeData(edgeID).distance;
             ++aindex;
         }
 
@@ -279,55 +318,65 @@ private:
         int bindex = packedShortestPath.size()-1;
         //compute backward sharing
         while( aindex > 0 && bindex > 0 && (packedAlternativePath[aindex] == packedShortestPath[bindex]) && (packedAlternativePath[aindex-1] == packedShortestPath[bindex-1]) ) {
-            typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection(packedAlternativePath[aindex], packedAlternativePath[aindex-1]);
-            sharing += super::_queryData.graph->GetEdgeData(edgeID).distance;
+            typename SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection(packedAlternativePath[aindex], packedAlternativePath[aindex-1]);
+            sharing += search_graph->GetEdgeData(edgeID).distance;
             --aindex; --bindex;
         }
         return sharing;
     }
 
-    inline void AlternativeRoutingStep(HeapPtr & _forwardHeap, HeapPtr & _backwardHeap, NodeID *middle, int *_upperbound, const int edgeBasedOffset, const bool forwardDirection, std::vector<NodeID>& searchSpaceIntersection) const {
-        const NodeID node = _forwardHeap->DeleteMin();
+    template<bool forwardDirection>
+    inline void AlternativeRoutingStep(
+    		QueryHeap & _forward_heap,
+    		QueryHeap & _reverse_heap,
+    		NodeID *middle_node,
+    		int *upper_bound_to_shortest_path_distance,
+    		std::vector<NodeID>& searchSpaceIntersection,
+    		std::vector<SearchSpaceEdge> & search_space,
+    		const int edgeBasedOffset
+    		) const {
+        const NodeID node = _forward_heap.DeleteMin();
+        const int distance = _forward_heap.GetKey(node);
+        int scaledDistance = (distance-edgeBasedOffset)/(1.+VIAPATH_EPSILON);
+        if(scaledDistance > *upper_bound_to_shortest_path_distance){
+            _forward_heap.DeleteAll();
+            return;
+        }
 
-        const int distance = _forwardHeap->GetKey(node);
-        if(_backwardHeap->WasInserted(node) ){
+        search_space.push_back(std::make_pair(_forward_heap.GetData( node ).parent, node));
+
+        if(_reverse_heap.WasInserted(node) ){
             searchSpaceIntersection.push_back(node);
 
-            const int newDistance = _backwardHeap->GetKey(node) + distance;
-            if(newDistance < *_upperbound ){
+            const int newDistance = _reverse_heap.GetKey(node) + distance;
+            if(newDistance < *upper_bound_to_shortest_path_distance ){
                 if(newDistance>=0 ) {
-                    *middle = node;
-                    *_upperbound = newDistance;
+                    *middle_node = node;
+                    *upper_bound_to_shortest_path_distance = newDistance;
                 }
             }
         }
 
-        int scaledDistance = (distance-edgeBasedOffset)/(1.+VIAPATH_EPSILON);
-        if(scaledDistance > *_upperbound){
-            _forwardHeap->DeleteAll();
-            return;
-        }
-
-        for ( typename QueryDataT::Graph::EdgeIterator edge = super::_queryData.graph->BeginEdges( node ); edge < super::_queryData.graph->EndEdges(node); edge++ ) {
-            const typename QueryDataT::Graph::EdgeData & data = super::_queryData.graph->GetEdgeData(edge);
+        for ( typename SearchGraph::EdgeIterator edge = search_graph->BeginEdges( node ); edge < search_graph->EndEdges(node); edge++ ) {
+            const typename SearchGraph::EdgeData & data = search_graph->GetEdgeData(edge);
             bool forwardDirectionFlag = (forwardDirection ? data.forward : data.backward );
             if(forwardDirectionFlag) {
 
-                const NodeID to = super::_queryData.graph->GetTarget(edge);
+                const NodeID to = search_graph->GetTarget(edge);
                 const int edgeWeight = data.distance;
 
                 assert( edgeWeight > 0 );
                 const int toDistance = distance + edgeWeight;
 
                 //New Node discovered -> Add to Heap + Node Info Storage
-                if ( !_forwardHeap->WasInserted( to ) ) {
-                    _forwardHeap->Insert( to, toDistance, node );
+                if ( !_forward_heap.WasInserted( to ) ) {
+                    _forward_heap.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 );
+                else if ( toDistance < _forward_heap.GetKey( to ) ) {
+                    _forward_heap.GetData( to ).parent = node;
+                    _forward_heap.DecreaseKey( to, toDistance );
                     //new parent
                 }
             }
@@ -335,16 +384,17 @@ private:
     }
 
     //conduct T-Test
-    inline bool viaNodeCandidatePasses_T_Test( HeapPtr& existingForwardHeap, HeapPtr& existingBackwardHeap, HeapPtr& newForwardHeap, HeapPtr& newBackwardHeap, const RankedCandidateNode& candidate, const int offset, const int lengthOfShortestPath, int * lengthOfViaPath, NodeID * s_v_middle, NodeID * v_t_middle) {
+    inline bool viaNodeCandidatePasses_T_Test( QueryHeap& existingForwardHeap, QueryHeap& existingBackwardHeap, QueryHeap& newForwardHeap, QueryHeap& newBackwardHeap, const RankedCandidateNode& candidate, const int offset, const int lengthOfShortestPath, int * lengthOfViaPath, NodeID * s_v_middle, NodeID * v_t_middle) {
+    	newForwardHeap.Clear();
+    	newBackwardHeap.Clear();
         std::vector < NodeID > packed_s_v_path;
         std::vector < NodeID > packed_v_t_path;
 
-        super::_queryData.InitializeOrClearSecondThreadLocalStorage();
         *s_v_middle = UINT_MAX;
         int upperBoundFor_s_v_Path = INT_MAX;
         //compute path <s,..,v> by reusing forward search from s
-        newBackwardHeap->Insert(candidate.node, 0, candidate.node);
-        while (newBackwardHeap->Size() > 0) {
+        newBackwardHeap.Insert(candidate.node, 0, candidate.node);
+        while (newBackwardHeap.Size() > 0) {
             super::RoutingStep(newBackwardHeap, existingForwardHeap, s_v_middle, &upperBoundFor_s_v_Path, 2*offset, false);
         }
 
@@ -354,8 +404,8 @@ private:
         //compute path <v,..,t> by reusing backward search from t
         *v_t_middle = UINT_MAX;
         int upperBoundFor_v_t_Path = INT_MAX;
-        newForwardHeap->Insert(candidate.node, 0, candidate.node);
-        while (newForwardHeap->Size() > 0) {
+        newForwardHeap.Insert(candidate.node, 0, candidate.node);
+        while (newForwardHeap.Size() > 0) {
             super::RoutingStep(newForwardHeap, existingBackwardHeap, v_t_middle, &upperBoundFor_v_t_Path, 2*offset, true);
         }
 
@@ -369,14 +419,21 @@ private:
         super::RetrievePackedPathFromHeap(newForwardHeap, existingBackwardHeap, *v_t_middle, packed_v_t_path);
 
         NodeID s_P = *s_v_middle, t_P = *v_t_middle;
+        if(UINT_MAX == s_P) {
+            return false;
+        }
+
+        if(UINT_MAX == t_P) {
+            return false;
+        }
         const int T_threshold = VIAPATH_EPSILON * lengthOfShortestPath;
         int unpackedUntilDistance = 0;
 
-        std::stack<UnpackEdge> unpackStack;
+        std::stack<SearchSpaceEdge> unpackStack;
         //Traverse path s-->v
         for (unsigned i = packed_s_v_path.size() - 1; (i > 0) && unpackStack.empty(); --i) {
-            typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection( packed_s_v_path[i - 1], packed_s_v_path[i]);
-            int lengthOfCurrentEdge = super::_queryData.graph->GetEdgeData(edgeID).distance;
+            typename SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection( packed_s_v_path[i - 1], packed_s_v_path[i]);
+            int lengthOfCurrentEdge = search_graph->GetEdgeData(edgeID).distance;
             if (lengthOfCurrentEdge + unpackedUntilDistance >= T_threshold) {
                 unpackStack.push(std::make_pair(packed_s_v_path[i - 1], packed_s_v_path[i]));
             } else {
@@ -386,17 +443,17 @@ private:
         }
 
         while (!unpackStack.empty()) {
-            const UnpackEdge viaPathEdge = unpackStack.top();
+            const SearchSpaceEdge viaPathEdge = unpackStack.top();
             unpackStack.pop();
-            typename QueryDataT::Graph::EdgeIterator edgeIDInViaPath = super::_queryData.graph->FindEdgeInEitherDirection(viaPathEdge.first, viaPathEdge.second);
+            typename SearchGraph::EdgeIterator edgeIDInViaPath = search_graph->FindEdgeInEitherDirection(viaPathEdge.first, viaPathEdge.second);
             if(UINT_MAX == edgeIDInViaPath)
                 return false;
-            typename QueryDataT::Graph::EdgeData currentEdgeData = super::_queryData.graph->GetEdgeData(edgeIDInViaPath);
+            typename SearchGraph::EdgeData currentEdgeData = search_graph->GetEdgeData(edgeIDInViaPath);
             bool IsViaEdgeShortCut = currentEdgeData.shortcut;
             if (IsViaEdgeShortCut) {
                 const NodeID middleOfViaPath = currentEdgeData.id;
-                typename QueryDataT::Graph::EdgeIterator edgeIDOfSecondSegment = super::_queryData.graph->FindEdgeInEitherDirection(middleOfViaPath, viaPathEdge.second);
-                int lengthOfSecondSegment = super::_queryData.graph->GetEdgeData(edgeIDOfSecondSegment).distance;
+                typename SearchGraph::EdgeIterator edgeIDOfSecondSegment = search_graph->FindEdgeInEitherDirection(middleOfViaPath, viaPathEdge.second);
+                int lengthOfSecondSegment = search_graph->GetEdgeData(edgeIDOfSecondSegment).distance;
                 //attention: !unpacking in reverse!
                 //Check if second segment is the one to go over treshold? if yes add second segment to stack, else push first segment to stack and add distance of second one.
                 if (unpackedUntilDistance + lengthOfSecondSegment >= T_threshold) {
@@ -416,8 +473,8 @@ private:
         unpackedUntilDistance = 0;
         //Traverse path s-->v
         for (unsigned i = 0, lengthOfPackedPath = packed_v_t_path.size() - 1; (i < lengthOfPackedPath) && unpackStack.empty(); ++i) {
-            typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection( packed_v_t_path[i], packed_v_t_path[i + 1]);
-            int lengthOfCurrentEdge = super::_queryData.graph->GetEdgeData(edgeID).distance;
+            typename SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection( packed_v_t_path[i], packed_v_t_path[i + 1]);
+            int lengthOfCurrentEdge = search_graph->GetEdgeData(edgeID).distance;
             if (lengthOfCurrentEdge + unpackedUntilDistance >= T_threshold) {
                 unpackStack.push( std::make_pair(packed_v_t_path[i], packed_v_t_path[i + 1]));
             } else {
@@ -427,17 +484,17 @@ private:
         }
 
         while (!unpackStack.empty()) {
-            const UnpackEdge viaPathEdge = unpackStack.top();
+            const SearchSpaceEdge viaPathEdge = unpackStack.top();
             unpackStack.pop();
-            typename QueryDataT::Graph::EdgeIterator edgeIDInViaPath = super::_queryData.graph->FindEdgeInEitherDirection(viaPathEdge.first, viaPathEdge.second);
+            typename SearchGraph::EdgeIterator edgeIDInViaPath = search_graph->FindEdgeInEitherDirection(viaPathEdge.first, viaPathEdge.second);
             if(UINT_MAX == edgeIDInViaPath)
                 return false;
-            typename QueryDataT::Graph::EdgeData currentEdgeData = super::_queryData.graph->GetEdgeData(edgeIDInViaPath);
+            typename SearchGraph::EdgeData currentEdgeData = search_graph->GetEdgeData(edgeIDInViaPath);
             const bool IsViaEdgeShortCut = currentEdgeData.shortcut;
             if (IsViaEdgeShortCut) {
                 const NodeID middleOfViaPath = currentEdgeData.id;
-                typename QueryDataT::Graph::EdgeIterator edgeIDOfFirstSegment = super::_queryData.graph->FindEdgeInEitherDirection(viaPathEdge.first, middleOfViaPath);
-                int lengthOfFirstSegment = super::_queryData.graph->GetEdgeData( edgeIDOfFirstSegment).distance;
+                typename SearchGraph::EdgeIterator edgeIDOfFirstSegment = search_graph->FindEdgeInEitherDirection(viaPathEdge.first, middleOfViaPath);
+                int lengthOfFirstSegment = search_graph->GetEdgeData( edgeIDOfFirstSegment).distance;
                 //Check if first segment is the one to go over treshold? if yes first segment to stack, else push second segment to stack and add distance of first one.
                 if (unpackedUntilDistance + lengthOfFirstSegment >= T_threshold) {
                     unpackStack.push( std::make_pair(viaPathEdge.first, middleOfViaPath));
@@ -454,20 +511,21 @@ private:
 
         lengthOfPathT_Test_Path += unpackedUntilDistance;
         //Run actual T-Test query and compare if distances equal.
-        HeapPtr& forwardHeap = super::_queryData.forwardHeap3;
-        HeapPtr& backwardHeap = super::_queryData.backwardHeap3;
         super::_queryData.InitializeOrClearThirdThreadLocalStorage();
+
+        QueryHeap& forward_heap3 = *super::_queryData.forwardHeap3;
+        QueryHeap& backward_heap3 = *super::_queryData.backwardHeap3;
         int _upperBound = INT_MAX;
         NodeID middle = UINT_MAX;
-        forwardHeap->Insert(s_P, 0, s_P);
-        backwardHeap->Insert(t_P, 0, t_P);
+        forward_heap3.Insert(s_P, 0, s_P);
+        backward_heap3.Insert(t_P, 0, t_P);
         //exploration from s and t until deletemin/(1+epsilon) > _lengthOfShortestPath
-        while (forwardHeap->Size() + backwardHeap->Size() > 0) {
-            if (forwardHeap->Size() > 0) {
-                super::RoutingStep(forwardHeap, backwardHeap, &middle, &_upperBound, offset, true);
+        while (forward_heap3.Size() + backward_heap3.Size() > 0) {
+            if (forward_heap3.Size() > 0) {
+                super::RoutingStep(forward_heap3, backward_heap3, &middle, &_upperBound, offset, true);
             }
-            if (backwardHeap->Size() > 0) {
-                super::RoutingStep(backwardHeap, forwardHeap, &middle, &_upperBound, offset, false);
+            if (backward_heap3.Size() > 0) {
+                super::RoutingStep(backward_heap3, forward_heap3, &middle, &_upperBound, offset, false);
             }
         }
         return (_upperBound <= lengthOfPathT_Test_Path);

RoutingAlgorithms/BasicRoutingInterface.h

@@ -23,43 +23,46 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #ifndef BASICROUTINGINTERFACE_H_
 #define BASICROUTINGINTERFACE_H_
 
+#include "../Plugins/RawRouteData.h"
+#include "../Util/ContainerUtils.h"
+
+#include <boost/noncopyable.hpp>
+
 #include <cassert>
 #include <climits>
 
-#include "../Plugins/RawRouteData.h"
+#include <stack>
 
 template<class QueryDataT>
-class BasicRoutingInterface {
+class BasicRoutingInterface : boost::noncopyable{
 protected:
     QueryDataT & _queryData;
 public:
     BasicRoutingInterface(QueryDataT & qd) : _queryData(qd) { }
     virtual ~BasicRoutingInterface(){ };
 
-    inline void RoutingStep(typename QueryDataT::HeapPtr & _forwardHeap, typename QueryDataT::HeapPtr & _backwardHeap, NodeID *middle, int *_upperbound, const int edgeBasedOffset, const bool forwardDirection) const {
-        const NodeID node = _forwardHeap->DeleteMin();
-        const int distance = _forwardHeap->GetKey(node);
-//        INFO((forwardDirection ? "[forw]" : "[back]") << " settled node " << node << " at distance " << distance);
-        if(_backwardHeap->WasInserted(node) ){
-//            INFO((forwardDirection ? "[forw]"     : "[back]") << " scanned node " << node << " in both directions, upper bound: " << *_upperbound);
-            const int newDistance = _backwardHeap->GetKey(node) + distance;
+    inline void RoutingStep(typename QueryDataT::QueryHeap & _forwardHeap, typename QueryDataT::QueryHeap & _backwardHeap, NodeID *middle, int *_upperbound, const int edgeBasedOffset, const bool forwardDirection) const {
+        const NodeID node = _forwardHeap.DeleteMin();
+        const int distance = _forwardHeap.GetKey(node);
+        //INFO("Settled (" << _forwardHeap.GetData( node ).parent << "," << node << ")=" << distance);
+        if(_backwardHeap.WasInserted(node) ){
+            const int newDistance = _backwardHeap.GetKey(node) + distance;
             if(newDistance < *_upperbound ){
                 if(newDistance>=0 ) {
-//                    INFO((forwardDirection ? "[forw]" : "[back]") << " -> node " << node << " is new middle at total distance " << newDistance);
                     *middle = node;
                     *_upperbound = newDistance;
                 } else {
-//                    INFO((forwardDirection ? "[forw]" : "[back]") << " -> ignored " << node << " as new middle at total distance " << newDistance);
                 }
             }
         }
 
         if(distance-edgeBasedOffset > *_upperbound){
-            _forwardHeap->DeleteAll();
+            _forwardHeap.DeleteAll();
             return;
         }
 
-        for ( typename QueryDataT::Graph::EdgeIterator edge = _queryData.graph->BeginEdges( node ); edge < _queryData.graph->EndEdges(node); edge++ ) {
+        //Stalling
+        for ( typename QueryDataT::Graph::EdgeIterator edge = _queryData.graph->BeginEdges( node ); edge < _queryData.graph->EndEdges(node); ++edge ) {
             const typename QueryDataT::Graph::EdgeData & data = _queryData.graph->GetEdgeData(edge);
             bool backwardDirectionFlag = (!forwardDirection) ? data.forward : data.backward;
             if(backwardDirectionFlag) {
@@ -68,16 +71,15 @@ public:
 
                 assert( edgeWeight > 0 );
 
-                //Stalling
-                if(_forwardHeap->WasInserted( to )) {
-                    if(_forwardHeap->GetKey( to ) + edgeWeight < distance) {
+                if(_forwardHeap.WasInserted( to )) {
+                    if(_forwardHeap.GetKey( to ) + edgeWeight < distance) {
                         return;
                     }
                 }
             }
         }
 
-        for ( typename QueryDataT::Graph::EdgeIterator edge = _queryData.graph->BeginEdges( node ); edge < _queryData.graph->EndEdges(node); edge++ ) {
+        for ( typename QueryDataT::Graph::EdgeIterator edge = _queryData.graph->BeginEdges( node ); edge < _queryData.graph->EndEdges(node); ++edge ) {
             const typename QueryDataT::Graph::EdgeData & data = _queryData.graph->GetEdgeData(edge);
             bool forwardDirectionFlag = (forwardDirection ? data.forward : data.backward );
             if(forwardDirectionFlag) {
@@ -89,23 +91,20 @@ public:
                 const int toDistance = distance + edgeWeight;
 
                 //New Node discovered -> Add to Heap + Node Info Storage
-                if ( !_forwardHeap->WasInserted( to ) ) {
-                    //                    INFO((forwardDirection ? "[forw]" : "[back]") << " scanning edge (" << node << "," << to << ") with distance " << toDistance << ", edge length: " << data.distance);
-                    _forwardHeap->Insert( to, toDistance, node );
+                if ( !_forwardHeap.WasInserted( to ) ) {
+                    _forwardHeap.Insert( to, toDistance, node );
                 }
                 //Found a shorter Path -> Update distance
-                else if ( toDistance < _forwardHeap->GetKey( to ) ) {
-                    //                    INFO((forwardDirection ? "[forw]" : "[back]") << " decrease and scanning edge (" << node << "," << to << ") from " << _forwardHeap->GetKey(to) << "to " << toDistance << ", edge length: " << data.distance);
-                    _forwardHeap->GetData( to ).parent = node;
-                    _forwardHeap->DecreaseKey( to, toDistance );
+                else if ( toDistance < _forwardHeap.GetKey( to ) ) {
+                    _forwardHeap.GetData( to ).parent = node;
+                    _forwardHeap.DecreaseKey( to, toDistance );
                     //new parent
                 }
             }
         }
     }
 
-    inline void UnpackPath(std::vector<NodeID> & packedPath, std::vector<_PathData> & unpackedPath) const {
-
+    inline void UnpackPath(const std::vector<NodeID> & packedPath, std::vector<_PathData> & unpackedPath) const {
         const unsigned sizeOfPackedPath = packedPath.size();
         std::stack<std::pair<NodeID, NodeID> > recursionStack;
 
@@ -118,15 +117,12 @@ public:
         while(!recursionStack.empty()) {
             edge = recursionStack.top();
             recursionStack.pop();
-//            INFO("Unpacking edge (" << edge.first << "," << edge.second << ")");
 
             typename QueryDataT::Graph::EdgeIterator smallestEdge = SPECIAL_EDGEID;
             int smallestWeight = INT_MAX;
             for(typename QueryDataT::Graph::EdgeIterator eit = _queryData.graph->BeginEdges(edge.first);eit < _queryData.graph->EndEdges(edge.first);++eit){
                 const int weight = _queryData.graph->GetEdgeData(eit).distance;
-//                INFO("Checking edge (" << edge.first << "/" << _queryData.graph->GetTarget(eit) << ")");
                 if(_queryData.graph->GetTarget(eit) == edge.second && weight < smallestWeight && _queryData.graph->GetEdgeData(eit).forward){
-//                    INFO("1smallest " << eit << ", " << weight);
                     smallestEdge = eit;
                     smallestWeight = weight;
                 }
@@ -135,9 +131,7 @@ public:
             if(smallestEdge == SPECIAL_EDGEID){
                 for(typename QueryDataT::Graph::EdgeIterator eit = _queryData.graph->BeginEdges(edge.second);eit < _queryData.graph->EndEdges(edge.second);++eit){
                     const int weight = _queryData.graph->GetEdgeData(eit).distance;
-//                    INFO("Checking edge (" << edge.first << "/" << _queryData.graph->GetTarget(eit) << ")");
                     if(_queryData.graph->GetTarget(eit) == edge.first && weight < smallestWeight && _queryData.graph->GetEdgeData(eit).backward){
-//                      INFO("2smallest " << eit << ", " << weight);
                         smallestEdge = eit;
                         smallestWeight = weight;
                     }
@@ -159,7 +153,6 @@ public:
     }
 
     inline void UnpackEdge(const NodeID s, const NodeID t, std::vector<NodeID> & unpackedPath) const {
-
         std::stack<std::pair<NodeID, NodeID> > recursionStack;
         recursionStack.push(std::make_pair(s,t));
 
@@ -193,7 +186,6 @@ public:
             if(ed.shortcut) {//unpack
                 const NodeID middle = ed.id;
                 //again, we need to this in reversed order
-//                INFO("unpacking (" << middle << "," <<  edge.second << ") and (" << edge.first << "," << middle << ")");
                 recursionStack.push(std::make_pair(middle, edge.second));
                 recursionStack.push(std::make_pair(edge.first, middle));
             } else {
@@ -204,22 +196,29 @@ public:
         unpackedPath.push_back(t);
     }
 
-    inline void RetrievePackedPathFromHeap(const typename QueryDataT::HeapPtr & _fHeap, const typename QueryDataT::HeapPtr & _bHeap, const NodeID middle, std::vector<NodeID>& packedPath) {
+    inline void RetrievePackedPathFromHeap(typename QueryDataT::QueryHeap & _fHeap, typename QueryDataT::QueryHeap & _bHeap, const NodeID middle, std::vector<NodeID>& packedPath) const {
         NodeID pathNode = middle;
-        while(pathNode != _fHeap->GetData(pathNode).parent) {
-            pathNode = _fHeap->GetData(pathNode).parent;
+        while(pathNode != _fHeap.GetData(pathNode).parent) {
+            pathNode = _fHeap.GetData(pathNode).parent;
             packedPath.push_back(pathNode);
         }
 
         std::reverse(packedPath.begin(), packedPath.end());
-
         packedPath.push_back(middle);
         pathNode = middle;
-        while (pathNode != _bHeap->GetData(pathNode).parent){
-            pathNode = _bHeap->GetData(pathNode).parent;
+        while (pathNode != _bHeap.GetData(pathNode).parent){
+            pathNode = _bHeap.GetData(pathNode).parent;
             packedPath.push_back(pathNode);
     	}
     }
+
+    inline void RetrievePackedPathFromSingleHeap(typename QueryDataT::QueryHeap & search_heap, const NodeID middle, std::vector<NodeID>& packed_path) const {
+        NodeID pathNode = middle;
+        while(pathNode != search_heap.GetData(pathNode).parent) {
+            pathNode = search_heap.GetData(pathNode).parent;
+            packed_path.push_back(pathNode);
+        }
+    }
 };
 
 

RoutingAlgorithms/ShortestPathRouting.h

@@ -28,13 +28,14 @@ or see http://www.gnu.org/licenses/agpl.txt.
 template<class QueryDataT>
 class ShortestPathRouting : public BasicRoutingInterface<QueryDataT>{
     typedef BasicRoutingInterface<QueryDataT> super;
+    typedef typename QueryDataT::QueryHeap QueryHeap;
 public:
-    ShortestPathRouting(QueryDataT & qd) : super(qd) {}
+    ShortestPathRouting( QueryDataT & qd) : super(qd) {}
 
     ~ShortestPathRouting() {}
 
-    void operator()(std::vector<PhantomNodes> & phantomNodesVector,  RawRouteData & rawRouteData) {
-        BOOST_FOREACH(PhantomNodes & phantomNodePair, phantomNodesVector) {
+    void operator()(std::vector<PhantomNodes> & phantomNodesVector,  RawRouteData & rawRouteData) const {
+        BOOST_FOREACH(const PhantomNodes & phantomNodePair, phantomNodesVector) {
             if(!phantomNodePair.AtLeastOnePhantomNodeIsUINTMAX()) {
                 rawRouteData.lengthOfShortestPath = rawRouteData.lengthOfAlternativePath = INT_MAX;
                 return;
@@ -43,125 +44,108 @@ public:
         int distance1 = 0;
         int distance2 = 0;
 
-        bool searchFrom1stStartNode(true);
-        bool searchFrom2ndStartNode(true);
-        NodeID middle1 = ( NodeID ) UINT_MAX;
-        NodeID middle2 = ( NodeID ) UINT_MAX;
+        bool searchFrom1stStartNode = true;
+        bool searchFrom2ndStartNode = true;
+        NodeID middle1 = UINT_MAX;
+        NodeID middle2 = UINT_MAX;
         std::vector<NodeID> packedPath1;
         std::vector<NodeID> packedPath2;
 
-        typename QueryDataT::HeapPtr & forwardHeap = super::_queryData.forwardHeap;
-        typename QueryDataT::HeapPtr & backwardHeap = super::_queryData.backwardHeap;
-
-        typename QueryDataT::HeapPtr & forwardHeap2 = super::_queryData.forwardHeap2;
-        typename QueryDataT::HeapPtr & backwardHeap2 = super::_queryData.backwardHeap2;
+        super::_queryData.InitializeOrClearFirstThreadLocalStorage();
+        super::_queryData.InitializeOrClearSecondThreadLocalStorage();
+        super::_queryData.InitializeOrClearThirdThreadLocalStorage();
 
+        QueryHeap & forward_heap1 = *(super::_queryData.forwardHeap);
+        QueryHeap & reverse_heap1 = *(super::_queryData.backwardHeap);
+        QueryHeap & forward_heap2 = *(super::_queryData.forwardHeap2);
+        QueryHeap & reverse_heap2 = *(super::_queryData.backwardHeap2);
 
         //Get distance to next pair of target nodes.
-        BOOST_FOREACH(PhantomNodes & phantomNodePair, phantomNodesVector) {
-            super::_queryData.InitializeOrClearFirstThreadLocalStorage();
-            super::_queryData.InitializeOrClearSecondThreadLocalStorage();
-
+        BOOST_FOREACH(const PhantomNodes & phantomNodePair, phantomNodesVector) {
+            forward_heap1.Clear();	forward_heap2.Clear();
+            reverse_heap1.Clear();	reverse_heap2.Clear();
             int _localUpperbound1 = INT_MAX;
             int _localUpperbound2 = INT_MAX;
 
+            middle1 = UINT_MAX;
+            middle2 = UINT_MAX;
+
             //insert new starting nodes into forward heap, adjusted by previous distances.
             if(searchFrom1stStartNode) {
-                forwardHeap->Insert(phantomNodePair.startPhantom.edgeBasedNode, -phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
-                forwardHeap2->Insert(phantomNodePair.startPhantom.edgeBasedNode, -phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
-//              INFO("a 1,2)forw insert " << phantomNodePair.startPhantom.edgeBasedNode << " with weight " << phantomNodePair.startPhantom.weight1);
-//          } else {
-//              INFO("Skipping first start node");
-            }
+                forward_heap1.Insert(phantomNodePair.startPhantom.edgeBasedNode, -phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
+                INFO("fw1: " << phantomNodePair.startPhantom.edgeBasedNode << "´, w: " << -phantomNodePair.startPhantom.weight1);
+                forward_heap2.Insert(phantomNodePair.startPhantom.edgeBasedNode, -phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
+                INFO("fw2: " << phantomNodePair.startPhantom.edgeBasedNode << "´, w: " << -phantomNodePair.startPhantom.weight1);
+           }
             if(phantomNodePair.startPhantom.isBidirected() && searchFrom2ndStartNode) {
-                forwardHeap->Insert(phantomNodePair.startPhantom.edgeBasedNode+1, -phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
-                forwardHeap2->Insert(phantomNodePair.startPhantom.edgeBasedNode+1, -phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
-//              INFO("b 1,2)forw insert " << phantomNodePair.startPhantom.edgeBasedNode+1 << " with weight " << -phantomNodePair.startPhantom.weight1);
-//          } else if(!searchFrom2ndStartNode) {
-//              INFO("Skipping second start node");
+                forward_heap1.Insert(phantomNodePair.startPhantom.edgeBasedNode+1, -phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
+                INFO("fw1: " << phantomNodePair.startPhantom.edgeBasedNode+1 << "´, w: " << -phantomNodePair.startPhantom.weight2);
+                forward_heap2.Insert(phantomNodePair.startPhantom.edgeBasedNode+1, -phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
+                INFO("fw2: " << phantomNodePair.startPhantom.edgeBasedNode+1 << "´, w: " << -phantomNodePair.startPhantom.weight2);
             }
 
-//            backwardHeap->Clear();
-//            backwardHeap2->Clear();
             //insert new backward nodes into backward heap, unadjusted.
-            backwardHeap->Insert(phantomNodePair.targetPhantom.edgeBasedNode, phantomNodePair.targetPhantom.weight1, phantomNodePair.targetPhantom.edgeBasedNode);
-//          INFO("1) back insert " << phantomNodePair.targetPhantom.edgeBasedNode << " with weight " << phantomNodePair.targetPhantom.weight1);
+            reverse_heap1.Insert(phantomNodePair.targetPhantom.edgeBasedNode, phantomNodePair.targetPhantom.weight1, phantomNodePair.targetPhantom.edgeBasedNode);
+            INFO("rv1: " << phantomNodePair.targetPhantom.edgeBasedNode << ", w;" << phantomNodePair.targetPhantom.weight1 );
             if(phantomNodePair.targetPhantom.isBidirected() ) {
-//              INFO("2) back insert " << phantomNodePair.targetPhantom.edgeBasedNode+1 << " with weight " << phantomNodePair.targetPhantom.weight2);
-                backwardHeap2->Insert(phantomNodePair.targetPhantom.edgeBasedNode+1, phantomNodePair.targetPhantom.weight2, phantomNodePair.targetPhantom.edgeBasedNode+1);
-            }
-            int offset = (phantomNodePair.startPhantom.isBidirected() ? std::max(phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.weight2) : phantomNodePair.startPhantom.weight1) ;
-            offset += (phantomNodePair.targetPhantom.isBidirected() ? std::max(phantomNodePair.targetPhantom.weight1, phantomNodePair.targetPhantom.weight2) : phantomNodePair.targetPhantom.weight1) ;
+                reverse_heap2.Insert(phantomNodePair.targetPhantom.edgeBasedNode+1, phantomNodePair.targetPhantom.weight2, phantomNodePair.targetPhantom.edgeBasedNode+1);
+                INFO("rv2: " << phantomNodePair.targetPhantom.edgeBasedNode+1 << ", w;" << phantomNodePair.targetPhantom.weight2 );
+           }
+            const int forward_offset = phantomNodePair.startPhantom.weight1 + (phantomNodePair.startPhantom.isBidirected() ? phantomNodePair.startPhantom.weight2 : 0);
+            const int reverse_offset = phantomNodePair.targetPhantom.weight1 + (phantomNodePair.targetPhantom.isBidirected() ? phantomNodePair.targetPhantom.weight2 : 0);
 
             //run two-Target Dijkstra routing step.
-            while(forwardHeap->Size() + backwardHeap->Size() > 0){
-                if(forwardHeap->Size() > 0){
-                    super::RoutingStep(forwardHeap, backwardHeap, &middle1, &_localUpperbound1, 2*offset, true);
+            while(0 < (forward_heap1.Size() + reverse_heap1.Size() )){
+                if(0 < forward_heap1.Size()){
+                    super::RoutingStep(forward_heap1, reverse_heap1, &middle1, &_localUpperbound1, forward_offset, true);
                 }
-                if(backwardHeap->Size() > 0){
-                    super::RoutingStep(backwardHeap, forwardHeap, &middle1, &_localUpperbound1, 2*offset, false);
+                if(0 < reverse_heap1.Size() ){
+                    super::RoutingStep(reverse_heap1, forward_heap1, &middle1, &_localUpperbound1, reverse_offset, false);
                 }
             }
-            if(backwardHeap2->Size() > 0) {
-                while(forwardHeap2->Size() + backwardHeap2->Size() > 0){
-                    if(forwardHeap2->Size() > 0){
-                        super::RoutingStep(forwardHeap2, backwardHeap2, &middle2, &_localUpperbound2, 2*offset, true);
+            if(0 < reverse_heap2.Size()) {
+                while(0 < (forward_heap2.Size() + reverse_heap2.Size() )){
+                    if(0 < forward_heap2.Size()){
+                        super::RoutingStep(forward_heap2, reverse_heap2, &middle2, &_localUpperbound2, forward_offset, true);
                     }
-                    if(backwardHeap2->Size() > 0){
-                        super::RoutingStep(backwardHeap2, forwardHeap2, &middle2, &_localUpperbound2, 2*offset, false);
+                    if(0 < reverse_heap2.Size()){
+                        super::RoutingStep(reverse_heap2, forward_heap2, &middle2, &_localUpperbound2, reverse_offset, false);
                     }
                 }
             }
-//          INFO("upperbound1: " << _localUpperbound1 << ", distance1: " << distance1);
-//          INFO("upperbound2: " << _localUpperbound2 << ", distance2: " << distance2);
 
             //No path found for both target nodes?
-            if(INT_MAX == _localUpperbound1 && INT_MAX == _localUpperbound2) {
+            if((INT_MAX == _localUpperbound1) && (INT_MAX == _localUpperbound2)) {
                 rawRouteData.lengthOfShortestPath = rawRouteData.lengthOfAlternativePath = INT_MAX;
                 return;
             }
             if(UINT_MAX == middle1) {
                 searchFrom1stStartNode = false;
-//              INFO("Next Search will not start from 1st");
-            } else {
-//              INFO("Next Search will start from 1st");
-                searchFrom1stStartNode = true;
             }
             if(UINT_MAX == middle2) {
                 searchFrom2ndStartNode = false;
-//              INFO("Next Search will not start from 2nd");
-            } else {
-                searchFrom2ndStartNode = true;
-//              INFO("Next Search will start from 2nd");
             }
 
             //Was at most one of the two paths not found?
             assert(!(INT_MAX == distance1 && INT_MAX == distance2));
 
-//          INFO("middle1: " << middle1);
-
             //Unpack paths if they exist
             std::vector<NodeID> temporaryPackedPath1;
             std::vector<NodeID> temporaryPackedPath2;
             if(INT_MAX != _localUpperbound1) {
-                super::RetrievePackedPathFromHeap(forwardHeap, backwardHeap, middle1, temporaryPackedPath1);
-//              INFO("temporaryPackedPath1 ends with " << *(temporaryPackedPath1.end()-1) );
+                super::RetrievePackedPathFromHeap(forward_heap1, reverse_heap1, middle1, temporaryPackedPath1);
             }
-//          INFO("middle2: " << middle2);
 
             if(INT_MAX != _localUpperbound2) {
-                super::RetrievePackedPathFromHeap(forwardHeap2, backwardHeap2, middle2, temporaryPackedPath2);
-//                INFO("temporaryPackedPath2 ends with " << *(temporaryPackedPath2.end()-1) );
+                super::RetrievePackedPathFromHeap(forward_heap2, reverse_heap2, middle2, temporaryPackedPath2);
             }
 
             //if one of the paths was not found, replace it with the other one.
             if(0 == temporaryPackedPath1.size()) {
-//              INFO("Deleting path 1");
                 temporaryPackedPath1.insert(temporaryPackedPath1.end(), temporaryPackedPath2.begin(), temporaryPackedPath2.end());
                 _localUpperbound1 = _localUpperbound2;
             }
             if(0 == temporaryPackedPath2.size()) {
-//              INFO("Deleting path 2");
                 temporaryPackedPath2.insert(temporaryPackedPath2.end(), temporaryPackedPath1.begin(), temporaryPackedPath1.end());
                 _localUpperbound2 = _localUpperbound1;
             }
@@ -170,28 +154,21 @@ public:
 
             //Plug paths together, s.t. end of packed path is begin of temporary packed path
             if(0 < packedPath1.size() && 0 < packedPath2.size() ) {
-//              INFO("Both paths are non-empty");
                 if( *(temporaryPackedPath1.begin()) == *(temporaryPackedPath2.begin())) {
-//                  INFO("both paths start with the same node:" << *(temporaryPackedPath1.begin()));
                     //both new route segments start with the same node, thus one of the packedPath must go.
                     assert( (packedPath1.size() == packedPath2.size() ) || (*(packedPath1.end()-1) != *(packedPath2.end()-1)) );
                     if( *(packedPath1.end()-1) == *(temporaryPackedPath1.begin())) {
-//                      INFO("Deleting packedPath2 that ends with " << *(packedPath2.end()-1) << ", other ends with " << *(packedPath1.end()-1));
                         packedPath2.clear();
                         packedPath2.insert(packedPath2.end(), packedPath1.begin(), packedPath1.end());
                         distance2 = distance1;
-//                      INFO("packedPath2 now ends with " <<  *(packedPath2.end()-1));
                     } else {
-//                      INFO("Deleting path1 that ends with " << *(packedPath1.end()-1) << ", other ends with " << *(packedPath2.end()-1));
                         packedPath1.clear();
                         packedPath1.insert(packedPath1.end(), packedPath2.begin(), packedPath2.end());
                         distance1 = distance2;
-//                      INFO("Path1 now ends with " <<  *(packedPath1.end()-1));
                     }
                 } else  {
                     //packed paths 1 and 2 may need to switch.
                     if(*(packedPath1.end()-1) != *(temporaryPackedPath1.begin())) {
-//                      INFO("Switching");
                         packedPath1.swap(packedPath2);
                         std::swap(distance1, distance2);
                     }
@@ -201,61 +178,24 @@ public:
             packedPath2.insert(packedPath2.end(), temporaryPackedPath2.begin(), temporaryPackedPath2.end());
 
             if( (packedPath1.back() == packedPath2.back()) && phantomNodePair.targetPhantom.isBidirected() ) {
-//              INFO("both paths end in same direction on bidirected edge, make sure start only start with : " << packedPath1.back());
 
                 NodeID lastNodeID = packedPath2.back();
                 searchFrom1stStartNode &= !(lastNodeID == phantomNodePair.targetPhantom.edgeBasedNode+1);
                 searchFrom2ndStartNode &= !(lastNodeID == phantomNodePair.targetPhantom.edgeBasedNode);
-//                INFO("Next search from node " << phantomNodePair.targetPhantom.edgeBasedNode << ": " << (searchFrom1stStartNode ? "yes" : "no") );
-//                INFO("Next search from node " << phantomNodePair.targetPhantom.edgeBasedNode+1 << ": " << (searchFrom2ndStartNode ? "yes" : "no") );
             }
 
             distance1 += _localUpperbound1;
             distance2 += _localUpperbound2;
         }
 
-//      INFO("length path1: " << distance1);
-//      INFO("length path2: " << distance2);
-        if(distance1 <= distance2){
-            //remove consecutive duplicates
-//          std::cout << "unclean 1: ";
-//          for(unsigned i = 0; i < packedPath1.size(); ++i)
-//              std::cout << packedPath1[i] << " ";
-//          std::cout << std::endl;
-
-//          std::cout << "cleaned 1: ";
-//          for(unsigned i = 0; i < packedPath1.size(); ++i)
-//              std::cout << packedPath1[i] << " ";
-//          std::cout << std::endl;
-//            super::UnpackPath(packedPath1, rawRouteData.computedShortestPath);
-        } else {
+        if(distance1 > distance2){
             std::swap(packedPath1, packedPath2);
-//          std::cout << "unclean 2: ";
-//          for(unsigned i = 0; i < packedPath2.size(); ++i)
-//              std::cout << packedPath2[i] << " ";
-//          std::cout << std::endl;
-//            _RemoveConsecutiveDuplicatesFromContainer(packedPath2);
-//          std::cout << "cleaned 2: ";
-//          for(unsigned i = 0; i < packedPath2.size(); ++i)
-//              std::cout << packedPath2[i] << " ";
-//          std::cout << std::endl;
-//            super::UnpackPath(packedPath2, unpackedPath);
         }
-        _RemoveConsecutiveDuplicatesFromContainer(packedPath1);
+        remove_consecutive_duplicates_from_vector(packedPath1);
         super::UnpackPath(packedPath1, rawRouteData.computedShortestPath);
         rawRouteData.lengthOfShortestPath = std::min(distance1, distance2);
-//      INFO("Found via route with distance " << std::min(distance1, distance2));
         return;
     }
-private:
-    template<class ContainerT>
-    void _RemoveConsecutiveDuplicatesFromContainer(ContainerT & packedPath) {
-        //remove consecutive duplicates
-        typename ContainerT::iterator it;
-        // using default comparison:
-        it = std::unique(packedPath.begin(), packedPath.end());
-        packedPath.resize(it - packedPath.begin());
-    }
 };
 
 #endif /* SHORTESTPATHROUTING_H_ */

SConstruct

@@ -1,299 +0,0 @@
-#Sconstruct
-
-import os
-import os.path
-import string
-import sys
-from subprocess import call
-
-def CheckBoost(context, version):
-    # Boost versions are in format major.minor.subminor
-    v_arr = version.split(".")
-    version_n = 0
-    if len(v_arr) > 0:
-        version_n += int(v_arr[0])*100000
-    if len(v_arr) > 1:
-        version_n += int(v_arr[1])*100
-    if len(v_arr) > 2:
-        version_n += int(v_arr[2])
-    
-    context.Message('Checking for Boost version >= %s... ' % (version))
-    ret = context.TryRun("""
-    #include <boost/version.hpp>
-    
-    int main()
-    {
-        return BOOST_VERSION >= %d ? 0 : 1;
-    }
-    """ % version_n, '.cpp')[0]
-    context.Result(ret)
-    return ret
-
-def CheckProtobuf(context, version):
-    # Protobuf versions are in format major.minor.subminor
-    v_arr = version.split(".")
-    version_n = 0
-    if len(v_arr) > 0:
-        version_n += int(v_arr[0])*1000000
-    if len(v_arr) > 1:
-        version_n += int(v_arr[1])*1000
-    if len(v_arr) > 2:
-        version_n += int(v_arr[2])
-    
-    context.Message('Checking for Protobuffer version >= %s... ' % (version))
-    ret = context.TryRun("""
-    #include <google/protobuf/stubs/common.h>
-	int main() {
-	return (GOOGLE_PROTOBUF_VERSION >= %d) ? 0 : 1;
-    }
-    """ % version_n, '.cpp')[0]
-    context.Result(ret)
-    return ret
-
-# Adding various options to the SConstruct
-AddOption('--cxx', dest='cxx', type='string', nargs=1, action='store', metavar='STRING', help='C++ Compiler')
-AddOption('--stxxlroot', dest='stxxlroot', type='string', nargs=1, action='store', metavar='STRING', help='root directory of STXXL')
-AddOption('--verbosity', dest='verbosity', type='string', nargs=1, action='store', metavar='STRING', help='make Scons talking')
-AddOption('--buildconfiguration', dest='buildconfiguration', type='string', nargs=1, action='store', metavar='STRING', help='debug or release')
-AddOption('--all-flags', dest='allflags', type='string', nargs=0, action='store', metavar='STRING', help='turn off -march optimization in release mode')
-AddOption('--with-tools', dest='withtools', type='string', nargs=0, action='store', metavar='STRING', help='build tools for data analysis')
-AddOption('--no-march', dest='nomarch', type='string', nargs=0, action='store', metavar='STRING', help='turn off native optimizations')
-
-env = Environment( ENV = {'PATH' : os.environ['PATH']} ,COMPILER = GetOption('cxx'))
-env["CC"] = os.getenv("CC") or env["CC"]
-env["CXX"] = os.getenv("CXX") or env["CXX"]
-env["ENV"].update(x for x in os.environ.items() if x[0].startswith("CCC_"))
-try:
-	env['ENV']['TERM'] = os.environ['TERM']
-except KeyError:
-	env['ENV']['TERM'] = 'none'
-	
-conf = Configure(env, custom_tests = { 'CheckBoost' : CheckBoost, 'CheckProtobuf' : CheckProtobuf })
-
-if GetOption('cxx') is None:
-    #default Compiler
-    if sys.platform == 'darwin':	#Mac OS X
-        env['CXX'] = 'clang++'
-    print 'Using default C++ Compiler: ', env['CXX'].strip()
-else:
-    env.Replace(CXX = GetOption('cxx'))
-    print 'Using user supplied C++ Compiler: ', env['CXX']
-
-if GetOption('allflags') is not None:
-    env.Append(CXXFLAGS = ["-Wextra", "-Wall", "-Wnon-virtual-dtor", "-Wundef", "-Wno-long-long", "-Woverloaded-virtual", "-Wfloat-equal", "-Wredundant-decls"])
-
-if "clang" in env["CXX"]:
-    print "Warning building with clang removes OpenMP parallelization"
-    if GetOption('allflags') is not None:
-        env.Append(CXXFLAGS = ["-W#warnings", "-Wc++0x-compat", "-Waddress-of-temporary", "-Wambiguous-member-template", "-Warray-bounds", "-Watomic-properties", "-Wbind-to-temporary-copy", "-Wbuiltin-macro-redefined", "-Wc++-compat", "-Wc++0x-extensions", "-Wcomments", "-Wconditional-uninitialized", "-Wconstant-logical-operand", "-Wdeclaration-after-statement", "-Wdeprecated", "-Wdeprecated-implementations", "-Wdeprecated-writable-strings", "-Wduplicate-method-arg", "-Wempty-body", "-Wendif-labels", "-Wenum-compare", "-Wformat=2", "-Wfour-char-constants", "-Wgnu", "-Wincomplete-implementation", "-Winvalid-noreturn", "-Winvalid-offsetof", "-Winvalid-token-paste", "-Wlocal-type-template-args", "-Wmethod-signatures", "-Wmicrosoft", "-Wmissing-declarations", "-Wnon-pod-varargs", "-Wnonfragile-abi2", "-Wnull-dereference", "-Wout-of-line-declaration", "-Woverlength-strings", "-Wpacked", "-Wpointer-arith", "-Wpointer-sign", "-Wprotocol", "-Wreadonly-setter-attrs", "-Wselector", "-Wshift-overflow", "-Wshift-sign-overflow", "-Wstrict-selector-match", "-Wsuper-class-method-mismatch", "-Wtautological-compare", "-Wtypedef-redefinition", "-Wundeclared-selector", "-Wunnamed-type-template-args", "-Wunused-exception-parameter", "-Wunused-member-function", "-Wused-but-marked-unused", "-Wvariadic-macros"])
-else:
-	env.Append(CCFLAGS = ['-minline-all-stringops', '-fopenmp'])
-	env.Append(LINKFLAGS = '-fopenmp')
-
-if GetOption('buildconfiguration') == 'debug':
-	env.Append(CCFLAGS = ['-Wall', '-g3', '-rdynamic'])
-else:
-	env.Append(CCFLAGS = ['-O3', '-DNDEBUG'])
-
-if sys.platform == 'darwin':	#Mac OS X
-	#os x default installations
-	env.Append(CPPPATH = ['/usr/include/libxml2'] )
-	env.Append(CPPPATH = ['/usr/X11/include'])		#comes with os x
-#	env.Append(LIBPATH = ['/usr/X11/lib'])			#needed for libpng
-	
-	#assume stxxl and boost are installed via homebrew. call brew binary to get folder locations
-	import subprocess
-	stxxl_prefix = subprocess.check_output(["brew", "--prefix", "libstxxl"]).strip()
-	env.Append(CPPPATH = [stxxl_prefix+"/include"] )
-	env.Append(LIBPATH = [stxxl_prefix+"/lib"] )
-	boost_prefix = subprocess.check_output(["brew", "--prefix", "boost"]).strip()
-	env.Append(CPPPATH = [boost_prefix+"/include"] )
-	env.Append(LIBPATH = [boost_prefix+"/lib"] )
-	if not conf.CheckLibWithHeader('lua', 'lua.h', 'C'):
-		print "lua library not found. Exiting"
-		Exit(-1)
-	
-	if not conf.CheckLibWithHeader('luabind', 'luabind/luabind.hpp', 'CXX'):
-		print "luabind library not found. Exiting"
-		Exit(-1)
-
-elif sys.platform.startswith("freebsd"):
-	env.ParseConfig('pkg-config --cflags --libs protobuf')
-	env.Append(CPPPATH = ['/usr/local/include', '/usr/local/include/libxml2'])
-	env.Append(LIBPATH = ['/usr/local/lib'])
-	if GetOption('stxxlroot') is not None:
-	   env.Append(CPPPATH = GetOption('stxxlroot')+'/include')
-	   env.Append(LIBPATH = GetOption('stxxlroot')+'/lib')
-	   print 'STXXLROOT = ', GetOption('stxxlroot')
-elif sys.platform == 'win32':
-	#SCons really wants to use Microsoft compiler
-	print "Compiling is not yet supported on Windows"
-	Exit(-1)
-else:
-	print "Default platform"
-	if GetOption('stxxlroot') is not None:
-	   env.Append(CPPPATH = GetOption('stxxlroot')+'/include')
-	   env.Append(LIBPATH = GetOption('stxxlroot')+'/lib')
-	   print 'STXXLROOT = ', GetOption('stxxlroot')
-	env.Append(CPPPATH = ['/usr/include', '/usr/include/include', '/usr/include/libxml2/'])
-	if not conf.CheckLibWithHeader('pthread', 'pthread.h', 'CXX'):
-		print "pthread not found. Exiting"
-		Exit(-1)
-	
-	if not conf.CheckLibWithHeader('luajit-5.1', 'luajit-2.0/lua.h', 'CXX'):
-		print "luajit library not found. Checking for interpreter"
-		env.ParseConfig('pkg-config --cflags --libs lua5.1')
-	env.ParseConfig('pkg-config --cflags --libs luabind')
-
-#Check if architecture optimizations shall be turned off
-if GetOption('buildconfiguration') != 'debug' and sys.platform != 'darwin' and GetOption('nomarch') is None:
-	env.Append(CCFLAGS = ['-march=native'])
-
-if not conf.CheckHeader('omp.h'):
-	print "Compiler does not support OpenMP. Exiting"
-	Exit(-1)
-if not conf.CheckLibWithHeader('bz2', 'bzlib.h', 'CXX'):
-	print "bz2 library not found. Exiting"
-	Exit(-1)
-if GetOption('withtools') is not None:
-	if not conf.CheckLibWithHeader('gdal', 'gdal/gdal.h', 'CXX'):
-		print "gdal library not found. Exiting"
-		Exit(-1)
-if not conf.CheckLibWithHeader('osmpbf', 'osmpbf/osmpbf.h', 'CXX'):
-	print "osmpbf library not found. Exiting"
-	print "Either install libosmpbf-dev (Ubuntu) or use https://github.com/scrosby/OSM-binary"
-	Exit(-1)
-if not conf.CheckLibWithHeader('protobuf', 'google/protobuf/descriptor.h', 'CXX'):
-	print "Google Protobuffer library not found. Exiting"
-	Exit(-1)
-#check for protobuf 2.3.0
-if not (conf.CheckProtobuf('2.3.0')):
-	print 'libprotobuf version >= 2.3.0 needed'
-	Exit(-1);
-if not (env.Detect('protoc')):
-	print 'protobuffer compiler not found'
-	Exit(-1);
-if not conf.CheckLibWithHeader('stxxl', 'stxxl.h', 'CXX'):
-	print "stxxl library not found. Exiting"
-	Exit(-1)
-if not conf.CheckLibWithHeader('xml2', 'libxml/xmlreader.h', 'CXX'):
-	print "libxml2 library or header not found. Exiting"
-	Exit(-1)
-if not conf.CheckLibWithHeader('z', 'zlib.h', 'CXX'):
-	print "zlib library or header not found. Exiting"
-	Exit(-1)
-#Check BOOST installation
-if not (conf.CheckBoost('1.44')):
-	print 'Boost version >= 1.44 needed'
-	Exit(-1);
-if not conf.CheckLib('boost_system', language="C++"):
-	if not conf.CheckLib('boost_system-mt', language="C++"):
-		print "boost_system library not found. Exiting"
-		Exit(-1)
-	else:
-		print "using boost -mt"
-		env.Append(CCFLAGS = ' -lboost_system-mt')
-		env.Append(LINKFLAGS = ' -lboost_system-mt')
-if not conf.CheckLibWithHeader('boost_thread', 'boost/thread.hpp', 'CXX'):
-	if not conf.CheckLibWithHeader('boost_thread-mt', 'boost/thread.hpp', 'CXX'):
-		print "boost thread library not found. Exiting"
-		Exit(-1)
-	else:
-		print "using boost -mt"
-		env.Append(CCFLAGS = ' -lboost_thread-mt')
-		env.Append(LINKFLAGS = ' -lboost_thread-mt')
-if not conf.CheckLibWithHeader('boost_regex', 'boost/regex.hpp', 'CXX'):
-	if not conf.CheckLibWithHeader('boost_regex-mt', 'boost/regex.hpp', 'CXX'):
-		print "boost/regex.hpp not found. Exiting"
-		Exit(-1)
-	else:
-		print "using boost_regex -mt"
-		env.Append(CCFLAGS = ' -lboost_regex-mt')
-		env.Append(LINKFLAGS = ' -lboost_regex-mt')
-if not conf.CheckLib('boost_filesystem', language="C++"):
-	if not conf.CheckLib('boost_filesystem-mt', language="C++"):
-		print "boost_filesystem library not found. Exiting"
-		Exit(-1)
-	else:
-		print "using boost -mt"
-		env.Append(CCFLAGS = ' -lboost_filesystem-mt')
-		env.Append(LINKFLAGS = ' -lboost_filesystem-mt')
-if not conf.CheckCXXHeader('boost/archive/iterators/base64_from_binary.hpp'):
-	print "boost/archive/iterators/base64_from_binary.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/archive/iterators/binary_from_base64.hpp'):
-	print "boost/archive/iterators/binary_from_base64.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/archive/iterators/transform_width.hpp'):
-	print "boost/archive/iterators/transform_width.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/bind.hpp'):
-	print "boost/bind.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/circular_buffer.hpp'):
-	print "boost/circular_buffer.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/enable_shared_from_this.hpp'):
-	print "boost/bind.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/foreach.hpp'):
-	print "boost/foreach.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/lexical_cast.hpp'):
-	print "boost/foreach.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/logic/tribool.hpp'):
-	print "boost/foreach.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/math/tr1.hpp'):
-	print "boost/foreach.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/noncopyable.hpp'):
-	print "boost/noncopyable.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/property_tree/ptree.hpp'):
-	print "boost/property_tree/ptree.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/property_tree/ini_parser.hpp'):
-	print "boost/property_tree/ini_parser.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/shared_ptr.hpp'):
-	print "boost/shared_ptr.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/thread/mutex.hpp'):
-	print "boost/shared_ptr.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/thread/thread.hpp'):
-	print "boost/thread/thread.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/thread/condition.hpp'):
-	print "boost/thread/condition.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/thread/thread.hpp'):
-	print "boost/thread/thread.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/thread.hpp'):
-	print "boost thread header not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/tuple/tuple.hpp'):
-	print "boost thread header not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/unordered_map.hpp'):
-	print "boost thread header not found. Exiting"
-	Exit(-1)
-
-#checks for intels thread building blocks library
-#if not conf.CheckLibWithHeader('tbb', 'tbb/tbb.h', 'CXX'):
-#	print "Intel TBB library not found. Exiting"
-#	Exit(-1)
-#if not conf.CheckCXXHeader('tbb/task_scheduler_init.h'):
-#	print "tbb/task_scheduler_init.h not found. Exiting"
-#	Exit(-1)
-
-env.Program(target = 'osrm-extract', source = ["extractor.cpp", Glob('Util/*.cpp'), Glob('Extractor/*.cpp')])
-env.Program(target = 'osrm-prepare', source = ["createHierarchy.cpp", Glob('Contractor/*.cpp'), Glob('Util/SRTMLookup/*.cpp'), Glob('Algorithms/*.cpp')])
-env.Program(target = 'osrm-routed', source = ["routed.cpp", 'Descriptors/DescriptionFactory.cpp', Glob('ThirdParty/*.cc'), Glob('Server/DataStructures/*.cpp')], CCFLAGS = env['CCFLAGS'] + ['-DROUTED'])
-if GetOption('withtools') is not None:
-	env.Program(target = 'Tools/osrm-component', source = ["Tools/componentAnalysis.cpp"])
-env = conf.Finish()
-

Server/APIGrammar.h

@@ -33,7 +33,7 @@ template <typename Iterator, class HandlerT>
 struct APIGrammar : qi::grammar<Iterator> {
     APIGrammar(HandlerT * h) : APIGrammar::base_type(api_call), handler(h) {
         api_call = qi::lit('/') >> string[boost::bind(&HandlerT::setService, handler, ::_1)] >> *(query);
-        query    = ('?') >> (+(zoom | output | jsonp | checksum | location | hint | cmp | language | instruction | alt_route | old_API) ) ;
+        query    = ('?') >> (+(zoom | output | jsonp | checksum | location | hint | cmp | language | instruction | geometry | alt_route | old_API) ) ;
 
         zoom        = (-qi::lit('&')) >> qi::lit('z')            >> '=' >> qi::short_[boost::bind(&HandlerT::setZoomLevel, handler, ::_1)];
         output      = (-qi::lit('&')) >> qi::lit("output")       >> '=' >> string[boost::bind(&HandlerT::setOutputFormat, handler, ::_1)];

Server/BasicDatastructures.h

@@ -21,7 +21,10 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #ifndef BASIC_DATASTRUCTURES_H
 #define BASIC_DATASTRUCTURES_H
 #include <string>
-#include <boost/lexical_cast.hpp>
+#include <sstream>
+#include <boost/foreach.hpp>
+
+#include "../Util/StringUtil.h"
 
 namespace http {
 
@@ -70,15 +73,13 @@ struct Reply {
     std::vector<boost::asio::const_buffer> HeaderstoBuffers();
 	std::string content;
 	static Reply stockReply(status_type status);
-	void setSize(unsigned size) {
-	    for (std::size_t i = 0; i < headers.size(); ++i) {
-	            Header& h = headers[i];
-	            if("Content-Length" == h.name) {
-	                std::stringstream sizeString;
-	                sizeString << size;
-	                h.value = sizeString.str();
-	            }
-	    }
+	void setSize(const unsigned size) {
+		BOOST_FOREACH ( Header& h,  headers) {
+			if("Content-Length" == h.name) {
+				std::string sizeString;
+				intToString(size,h.value );
+			}
+		}
 	}
 };
 
@@ -138,11 +139,17 @@ Reply Reply::stockReply(Reply::status_type status) {
 	Reply rep;
 	rep.status = status;
 	rep.content = ToString(status);
-	rep.headers.resize(2);
-	rep.headers[0].name = "Content-Length";
-	rep.headers[0].value = boost::lexical_cast<std::string>(rep.content.size());
-	rep.headers[1].name = "Content-Type";
-	rep.headers[1].value = "text/html";
+	rep.headers.resize(3);	
+	rep.headers[0].name = "Access-Control-Allow-Origin";
+	rep.headers[0].value = "*";
+	rep.headers[1].name = "Content-Length";
+
+    std::string s;
+    intToString(rep.content.size(), s);
+
+    rep.headers[1].value = s;
+	rep.headers[2].name = "Content-Type";
+	rep.headers[2].value = "text/html";
 	return rep;
 }
 } // namespace http

Server/Connection.h

@@ -30,7 +30,6 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include <boost/shared_ptr.hpp>
 #include <boost/enable_shared_from_this.hpp>
 
-#include "../DataStructures/Util.h"
 #include "BasicDatastructures.h"
 #include "RequestHandler.h"
 #include "RequestParser.h"

Server/DataStructures/QueryObjectsStorage.cpp

@@ -22,14 +22,27 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include "QueryObjectsStorage.h"
 #include "../../Util/GraphLoader.h"
 
-QueryObjectsStorage::QueryObjectsStorage(std::string hsgrPath, std::string ramIndexPath, std::string fileIndexPath, std::string nodesPath, std::string edgesPath, std::string namesPath, std::string timestampPath) {
+QueryObjectsStorage::QueryObjectsStorage(
+	std::string hsgrPath,
+	std::string ramIndexPath,
+	std::string fileIndexPath,
+	std::string nodesPath,
+	std::string edgesPath,
+	std::string namesPath,
+	std::string timestampPath
+) {
 	INFO("loading graph data");
 	std::ifstream hsgrInStream(hsgrPath.c_str(), std::ios::binary);
     if(!hsgrInStream) { ERR(hsgrPath <<  " not found"); }
 	//Deserialize road network graph
 	std::vector< QueryGraph::_StrNode> nodeList;
 	std::vector< QueryGraph::_StrEdge> edgeList;
-	const int n = readHSGRFromStream(hsgrInStream, nodeList, edgeList, &checkSum);
+	const int n = readHSGRFromStream(
+		hsgrInStream,
+		nodeList,
+		edgeList,
+		&checkSum
+	);
 
 	INFO("Data checksum is " << checkSum);
 	graph = new QueryGraph(nodeList, edgeList);
@@ -39,7 +52,7 @@ QueryObjectsStorage::QueryObjectsStorage(std::string hsgrPath, std::string ramIn
 	if(timestampPath.length()) {
 	    INFO("Loading Timestamp");
 	    std::ifstream timestampInStream(timestampPath.c_str());
-	    if(!timestampInStream) { ERR(timestampPath <<  " not found"); }
+	    if(!timestampInStream) { WARN(timestampPath <<  " not found"); }
 
 	    getline(timestampInStream, timestamp);
 	    timestampInStream.close();

Server/RequestHandler.h

@@ -25,7 +25,6 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include <cctype> // std::tolower
 #include <string>
 #include <iostream>
-#include <boost/lexical_cast.hpp>
 #include <boost/noncopyable.hpp>
 
 #include "APIGrammar.h"
@@ -33,6 +32,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include "../DataStructures/HashTable.h"
 #include "../Plugins/BasePlugin.h"
 #include "../Plugins/RouteParameters.h"
+#include "../Util/StringUtil.h"
 #include "../typedefs.h"
 
 namespace http {
@@ -51,19 +51,20 @@ public:
 
     void handle_request(const Request& req, Reply& rep){
         //parse command
-        std::string request(req.uri);
-
-        { //This block logs the current request to std out. should be moved to a logging component
-            time_t ltime;
-            struct tm *Tm;
-
-            ltime=time(NULL);
-            Tm=localtime(&ltime);
-
-            INFO((Tm->tm_mday < 10 ? "0" : "" )  << Tm->tm_mday << "-" << (Tm->tm_mon+1 < 10 ? "0" : "" )  << (Tm->tm_mon+1) << "-" << 1900+Tm->tm_year << " " << (Tm->tm_hour < 10 ? "0" : "" ) << Tm->tm_hour << ":" << (Tm->tm_min < 10 ? "0" : "" ) << Tm->tm_min << ":" << (Tm->tm_sec < 10 ? "0" : "" ) << Tm->tm_sec << " " <<
-                    req.endpoint.to_string() << " " << req.referrer << ( 0 == req.referrer.length() ? "- " :" ") << req.agent << ( 0 == req.agent.length() ? "- " :" ") << req.uri );
-        }
         try {
+            std::string request(req.uri);
+
+            { //This block logs the current request to std out. should be moved to a logging component
+                time_t ltime;
+                struct tm *Tm;
+
+                ltime=time(NULL);
+                Tm=localtime(&ltime);
+
+                INFO((Tm->tm_mday < 10 ? "0" : "" )  << Tm->tm_mday << "-" << (Tm->tm_mon+1 < 10 ? "0" : "" )  << (Tm->tm_mon+1) << "-" << 1900+Tm->tm_year << " " << (Tm->tm_hour < 10 ? "0" : "" ) << Tm->tm_hour << ":" << (Tm->tm_min < 10 ? "0" : "" ) << Tm->tm_min << ":" << (Tm->tm_sec < 10 ? "0" : "" ) << Tm->tm_sec << " " <<
+                        req.endpoint.to_string() << " " << req.referrer << ( 0 == req.referrer.length() ? "- " :" ") << req.agent << ( 0 == req.agent.length() ? "- " :" ") << req.uri );
+            }
+
             RouteParameters routeParameters;
             APIGrammar<std::string::iterator, RouteParameters> apiParser(&routeParameters);
 
@@ -71,16 +72,17 @@ public:
             bool result = boost::spirit::qi::parse(it, request.end(), apiParser);    // returns true if successful
             if (!result || (it != request.end()) ) {
                 rep = http::Reply::stockReply(http::Reply::badRequest);
-                std::stringstream content;
                 int position = std::distance(request.begin(), it);
-                content << "Input seems to be malformed close to position " << position << "<br>";
-                content << "<pre>";
-                content << req.uri << "<br>";
+                std::string tmp_position_string;
+                intToString(position, tmp_position_string);
+                rep.content += "Input seems to be malformed close to position ";
+                rep.content += "<br><pre>";
+                rep.content += request;
+                rep.content += tmp_position_string;
+                rep.content += "<br>";
                 for(unsigned i = 0, end = std::distance(request.begin(), it); i < end; ++i)
-                    content << "&nbsp;";
-                content << "^" << "<br>";
-                content << "</pre>";
-                rep.content += content.str();
+                    rep.content += "&nbsp;";
+                rep.content += "^<br></pre>";
             } else {
                 //Finished parsing, lets call the right plugin to handle the request
                 if(pluginMap.Holds(routeParameters.service)) {

Util/ContainerUtils.h

@@ -0,0 +1,34 @@
+/*
+ * ContainerUtils.h
+ *
+ *  Created on: 02.02.2013
+ *      Author: dennis
+ */
+
+#ifndef CONTAINERUTILS_H_
+#define CONTAINERUTILS_H_
+
+#include <algorithm>
+#include <vector>
+
+template<typename T>
+inline void sort_unique_resize(std::vector<T> & vector) {
+	std::sort(vector.begin(), vector.end());
+	unsigned number_of_unique_elements = std::unique(vector.begin(), vector.end()) - vector.begin();
+	vector.resize(number_of_unique_elements);
+}
+
+template<typename T>
+inline void sort_unique_resize_shrink_vector(std::vector<T> & vector) {
+	sort_unique_resize(vector);
+	std::vector<T>().swap(vector);
+}
+
+template<typename T>
+inline void remove_consecutive_duplicates_from_vector(std::vector<T> & vector) {
+    unsigned number_of_unique_elements = std::unique(vector.begin(), vector.end()) - vector.begin();
+    vector.resize(number_of_unique_elements);
+}
+
+
+#endif /* CONTAINERUTILS_H_ */

Util/GraphLoader.h

@@ -21,6 +21,15 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #ifndef GRAPHLOADER_H
 #define GRAPHLOADER_H
 
+#include "../DataStructures/ImportNode.h"
+#include "../DataStructures/ImportEdge.h"
+#include "../DataStructures/NodeCoords.h"
+#include "../DataStructures/Restriction.h"
+#include "../typedefs.h"
+
+#include <boost/assert.hpp>
+#include <boost/unordered_map.hpp>
+
 #include <cassert>
 #include <cmath>
 
@@ -30,19 +39,11 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include <iomanip>
 #include <vector>
 
-#include <boost/unordered_map.hpp>
-
-#include "../DataStructures/ImportNode.h"
-#include "../DataStructures/ImportEdge.h"
-#include "../DataStructures/NodeCoords.h"
-#include "../DataStructures/Restriction.h"
-#include "../typedefs.h"
-
 typedef boost::unordered_map<NodeID, NodeID> ExternalNodeMap;
 
 template<class EdgeT>
 struct _ExcessRemover {
-    inline bool operator()( EdgeT & edge ) const {
+    inline bool operator()( const EdgeT & edge ) const {
         return edge.source() == UINT_MAX;
     }
 };
@@ -101,7 +102,7 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &in, std::vector<EdgeT>& edgeL
     short type;
     NodeID nameID;
     int length;
-    bool isRoundabout, ignoreInGrid, isAccessRestricted;
+    bool isRoundabout, ignoreInGrid, isAccessRestricted, isContraFlow;
 
     for (EdgeID i=0; i<m; ++i) {
         in.read((char*)&source,             sizeof(unsigned));
@@ -114,10 +115,11 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &in, std::vector<EdgeT>& edgeL
         in.read((char*)&isRoundabout,       sizeof(bool));
         in.read((char*)&ignoreInGrid,       sizeof(bool));
         in.read((char*)&isAccessRestricted, sizeof(bool));
+        in.read((char*)&isContraFlow,       sizeof(bool));
 
-        GUARANTEE(length > 0, "loaded null length edge" );
-        GUARANTEE(weight > 0, "loaded null weight");
-        GUARANTEE(0<=dir && dir<=2, "loaded bogus direction");
+        BOOST_ASSERT_MSG(length > 0, "loaded null length edge" );
+        BOOST_ASSERT_MSG(weight > 0, "loaded null weight");
+        BOOST_ASSERT_MSG(0<=dir && dir<=2, "loaded bogus direction");
 
         bool forward = true;
         bool backward = true;
@@ -143,14 +145,16 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &in, std::vector<EdgeT>& edgeL
             continue;
         }
         target = intNodeID->second;
-        GUARANTEE(source != UINT_MAX && target != UINT_MAX, "nonexisting source or target");
+        BOOST_ASSERT_MSG(source != UINT_MAX && target != UINT_MAX,
+            "nonexisting source or target"
+        );
 
         if(source > target) {
             std::swap(source, target);
             std::swap(forward, backward);
         }
 
-        EdgeT inputEdge(source, target, nameID, weight, forward, backward, type, isRoundabout, ignoreInGrid, isAccessRestricted );
+        EdgeT inputEdge(source, target, nameID, weight, forward, backward, type, isRoundabout, ignoreInGrid, isAccessRestricted, isContraFlow );
         edgeList.push_back(inputEdge);
     }
     std::sort(edgeList.begin(), edgeList.end());
@@ -169,14 +173,14 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &in, std::vector<EdgeT>& edgeL
                     edgeList[i]._source = UINT_MAX;
                 } else {
                     //edge i-1 is open in both directions, but edge i is smaller in one direction. Close edge i-1 in this direction
-                    edgeList[i-1].forward = ~edgeList[i].isForward();
-                    edgeList[i-1].backward = ~edgeList[i].isBackward();
+                    edgeList[i-1].forward = !edgeList[i].isForward();
+                    edgeList[i-1].backward = !edgeList[i].isBackward();
                 }
             } else if (edgeFlagsAreSuperSet2) {
                 if(edgeList[i-1].weight() <= edgeList[i].weight()) {
                      //edge i-1 is smaller for one direction. edge i is open in both. close edge i in the other direction
-                     edgeList[i].forward = ~edgeList[i-1].isForward();
-                     edgeList[i].backward = ~edgeList[i-1].isBackward();
+                     edgeList[i].forward = !edgeList[i-1].isForward();
+                     edgeList[i].backward = !edgeList[i-1].isBackward();
                  } else {
                      //edge i is smaller and goes in both direction. Throw away edge i-1
                      edgeList[i-1]._source = UINT_MAX;
@@ -184,9 +188,9 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &in, std::vector<EdgeT>& edgeL
             }
         }
     }
-    std::vector<ImportEdge>::iterator newEnd = std::remove_if(edgeList.begin(), edgeList.end(), _ExcessRemover<EdgeT>());
+    typename std::vector<EdgeT>::iterator newEnd = std::remove_if(edgeList.begin(), edgeList.end(), _ExcessRemover<EdgeT>());
     ext2IntNodeMap.clear();
-    std::vector<ImportEdge>(edgeList.begin(), newEnd).swap(edgeList); //remove excess candidates.
+    std::vector<EdgeT>(edgeList.begin(), newEnd).swap(edgeList); //remove excess candidates.
     INFO("Graph loaded ok and has " << edgeList.size() << " edges");
     return n;
 }
@@ -298,7 +302,7 @@ NodeID readDTMPGraphFromStream(std::istream &in, std::vector<EdgeT>& edgeList, s
         edgeList.push_back(inputEdge);
     }
     ext2IntNodeMap.clear();
-    std::vector<ImportEdge>(edgeList.begin(), edgeList.end()).swap(edgeList); //remove excess candidates.
+    std::vector<EdgeT>(edgeList.begin(), edgeList.end()).swap(edgeList); //remove excess candidates.
     std::cout << "ok" << std::endl;
     return n;
 }

Util/LuaUtil.h

@@ -0,0 +1,57 @@
+/*
+    open source routing machine
+    Copyright (C) Dennis Luxen, others 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+ */
+
+#ifndef LUAUTIL_H_
+#define LUAUTIL_H_
+
+extern "C" {
+    #include <lua.h>
+    #include <lauxlib.h>
+    #include <lualib.h>
+}
+
+#include <boost/filesystem/convenience.hpp>
+#include <luabind/luabind.hpp>
+#include <iostream>
+#include <string>
+
+template<typename T>
+void LUA_print(T number) {
+  std::cout << "[LUA] " << number << std::endl;
+}
+
+// Check if the lua function <name> is defined
+inline bool lua_function_exists(lua_State* lua_state, const char* name) {
+    luabind::object g = luabind::globals(lua_state);
+    luabind::object func = g[name];
+    return func && (luabind::type(func) == LUA_TFUNCTION);
+}
+
+// Add the folder contain the script to the lua load path, so script can easily require() other lua scripts inside that folder, or subfolders.
+// See http://lua-users.org/wiki/PackagePath for details on the package.path syntax.
+inline void luaAddScriptFolderToLoadPath(lua_State* myLuaState, const char* fileName) {
+    const boost::filesystem::path profilePath( fileName );
+    std::string folder = profilePath.parent_path().string();
+    //TODO: This code is most probably not Windows safe since it uses UNIX'ish path delimiters
+    const std::string luaCode = "package.path = \"" + folder + "/?.lua;profiles/?.lua;\" .. package.path";
+    luaL_dostring( myLuaState, luaCode.c_str() );
+}
+
+#endif /* LUAUTIL_H_ */

Util/MachineInfo.h

@@ -30,8 +30,29 @@ extern "C" {
 #include <windows.h>
 #endif
 
-/* Returns the physical memory size in kilobytes */
-unsigned GetPhysicalmemory(void){
+enum Endianness {
+    LittleEndian = 1,
+    BigEndian = 2
+};
+
+//Function is optimized to a single 'mov eax,1' on GCC, clang and icc using -O3
+inline Endianness getMachineEndianness() {
+    int i(1);
+    char *p = (char *) &i;
+    if (1 == p[0])
+        return LittleEndian;
+    return BigEndian;
+}
+
+// Reverses Network Byte Order into something usable, compiles down to a bswap-mov combination
+inline unsigned swapEndian(unsigned x) {
+    if(getMachineEndianness() == LittleEndian)
+        return ( (x>>24) | ((x<<8) & 0x00FF0000) | ((x>>8) & 0x0000FF00) | (x<<24) );
+    return x;
+}
+
+// Returns the physical memory size in kilobytes
+inline unsigned GetPhysicalmemory(void){
 #if defined(SUN5) || defined(__linux__)
 	return (sysconf(_SC_PHYS_PAGES) * sysconf(_SC_PAGESIZE));
 	
@@ -61,4 +82,5 @@ unsigned GetPhysicalmemory(void){
 
 #endif
 }
-#endif
+#endif // MACHINE_INFO_H
+

Util/StringUtil.h

@@ -21,14 +21,14 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #ifndef STRINGUTIL_H_
 #define STRINGUTIL_H_
 
-#include <cstdio>
-#include <cstdlib>
 #include <string>
-#include <sstream>
+#include <boost/algorithm/string.hpp>
 
 #include <boost/spirit/include/karma.hpp>
 #include <boost/spirit/include/qi.hpp>
 
+#include <cstdio>
+
 #include "../DataStructures/Coordinate.h"
 #include "../typedefs.h"
 
@@ -80,6 +80,20 @@ static inline int stringToInt(const std::string& input) {
     return value;
 }
 
+static inline void doubleToString(const double value, std::string & output){
+    output.clear();
+    std::back_insert_iterator<std::string> sink(output);
+    boost::spirit::karma::generate(sink, boost::spirit::karma::double_, value);
+}
+
+static inline void doubleToStringWithTwoDigitsBehindComma(const double value, std::string & output){
+    // The largest 32-bit integer is 4294967295, that is 10 chars
+    // On the safe side, add 1 for sign, and 1 for trailing zero
+    char buffer[12] ;
+    sprintf(buffer, "%g", value) ;
+    output = buffer ;
+}
+
 static inline void convertInternalLatLonToString(const int value, std::string & output) {
     char buffer[100];
     buffer[10] = 0; // Nullterminierung
@@ -106,70 +120,38 @@ static inline void convertInternalReversedCoordinateToString(const _Coordinate &
     output += " ";
 }
 
-static inline void doubleToString(const double value, std::string & output){
-    // The largest 32-bit integer is 4294967295, that is 10 chars
-    // On the safe side, add 1 for sign, and 1 for trailing zero
-    char buffer[12] ;
-    sprintf(buffer, "%f", value) ;
-    output = buffer ;
-}
-
-static inline void doubleToStringWithTwoDigitsBehindComma(const double value, std::string & output){
-    // The largest 32-bit integer is 4294967295, that is 10 chars
-    // On the safe side, add 1 for sign, and 1 for trailing zero
-    char buffer[12] ;
-    sprintf(buffer, "%g", value) ;
-    output = buffer ;
-}
-
-inline std::string & replaceAll(std::string &s, const std::string &sub, const std::string &other) {
-    assert(!sub.empty());
-    size_t b = 0;
-    for (;;) {
-        b = s.find(sub, b);
-        if (b == s.npos) break;
-        s.replace(b, sub.size(), other);
-        b += other.size();
-    }
-    return s;
+inline void replaceAll(std::string &s, const std::string &sub, const std::string &other) {
+	boost::replace_all(s, sub, other);
 }
 
 inline void stringSplit(const std::string &s, const char delim, std::vector<std::string>& result) {
-    std::stringstream ss(s);
-    std::string item;
-    while(std::getline(ss, item, delim)) {
-        if(item.size() > 0)
-            result.push_back(item);
-    }
+	boost::split(result, s, boost::is_any_of(std::string(&delim)));
 }
 
-
 static std::string originals[] = {"&", "\"",  "<",  ">", "'", "[", "]", "\\"};
 static std::string entities[] = {"&amp;", "&quot;", "&lt;", "&gt;", "&#39;", "&91;", "&93;", " &#92;" };
 
-inline std::string HTMLEntitize( std::string result) {
-    for(unsigned i = 0; i < sizeof(originals)/sizeof(std::string); i++) {
-        result = replaceAll(result, originals[i], entities[i]);
+inline std::string HTMLEntitize( const std::string & input) {
+    std::string result(input);
+    for(unsigned i = 0; i < sizeof(originals)/sizeof(std::string); ++i) {
+        replaceAll(result, originals[i], entities[i]);
     }
     return result;
 }
 
-inline std::string HTMLDeEntitize( std::string result) {
-    for(unsigned i = 0; i < sizeof(originals)/sizeof(std::string); i++) {
-        result = replaceAll(result, entities[i], originals[i]);
+inline std::string HTMLDeEntitize( std::string & result) {
+    for(unsigned i = 0; i < sizeof(originals)/sizeof(std::string); ++i) {
+        replaceAll(result, entities[i], originals[i]);
     }
     return result;
 }
 
-inline bool StringStartsWith(std::string & input, std::string & prefix) {
-    return (input.find(prefix) == 0);
+inline bool StringStartsWith(const std::string & input, const std::string & prefix) {
+    return boost::starts_with(input, prefix);
 }
 
-
-/*
- * Function returns a 'random' filename in temporary directors.
- * May not be platform independent.
- */
+// Function returns a 'random' filename in temporary directors.
+// May not be platform independent.
 inline void GetTemporaryFileName(std::string & filename) {
     char buffer[L_tmpnam];
     char * retPointer = tmpnam (buffer);

cmake/FindLuabind.cmake

@@ -0,0 +1,75 @@
+# Locate Luabind library
+# This module defines
+#  LUABIND_FOUND, if false, do not try to link to Luabind
+#  LUABIND_LIBRARIES
+#  LUABIND_INCLUDE_DIR, where to find luabind.hpp
+#
+# Note that the expected include convention is
+#  #include <luabind/luabind.hpp>
+# and not
+#  #include <luabind.hpp>
+
+IF( NOT LUABIND_FIND_QUIETLY )
+    MESSAGE(STATUS "Looking for Luabind...")
+ENDIF()
+
+FIND_PATH(LUABIND_INCLUDE_DIR luabind.hpp
+  HINTS
+  $ENV{LUABIND_DIR}
+  PATH_SUFFIXES luabind include/luabind include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local # DarwinPorts
+  /opt
+)
+
+FIND_LIBRARY(LUABIND_LIBRARY
+  NAMES luabind
+  HINTS
+  $ENV{LUABIND_DIR}
+  PATH_SUFFIXES lib64 lib
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local
+  /opt
+)
+
+FIND_LIBRARY(LUABIND_LIBRARY_DBG
+  NAMES luabindd
+  HINTS
+  $ENV{LUABIND_DIR}
+  PATH_SUFFIXES lib64 lib
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local
+  /opt
+)
+
+IF(LUABIND_LIBRARY)
+    SET( LUABIND_LIBRARIES "${LUABIND_LIBRARY}" CACHE STRING "Luabind Libraries")
+ENDIF(LUABIND_LIBRARY)
+
+INCLUDE(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set LUABIND_FOUND to TRUE if
+# all listed variables are TRUE
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Luabind  DEFAULT_MSG  LUABIND_LIBRARIES LUABIND_INCLUDE_DIR)
+
+IF( NOT LUABIND_FIND_QUIETLY )
+    IF( LUABIND_FOUND )
+        MESSAGE(STATUS "Found Luabind: ${LUABIND_LIBRARY}" )
+    ENDIF()
+    IF( LUABIND_LIBRARY_DBG )
+        MESSAGE(STATUS "Luabind debug library availible: ${LUABIND_LIBRARY_DBG}")
+    ENDIF()
+ENDIF()
+
+MARK_AS_ADVANCED(LUABIND_INCLUDE_DIR LUABIND_LIBRARIES LUABIND_LIBRARY LUABIND_LIBRARY_DBG) 

cmake/FindOSMPBF.cmake

@@ -0,0 +1,54 @@
+# Locate OSMPBF library
+# This module defines
+#  OSMPBF_FOUND, if false, do not try to link to OSMPBF
+#  OSMPBF_LIBRARIES
+#  OSMPBF_INCLUDE_DIR, where to find OSMPBF.hpp
+#
+# Note that the expected include convention is
+#  #include <osmpbf/osmpbf.h>
+# and not
+#  #include <osmpbf.h>
+
+IF( NOT OSMPBF_FIND_QUIETLY )
+    MESSAGE(STATUS "Looking for OSMPBF...")
+ENDIF()
+
+FIND_PATH(OSMPBF_INCLUDE_DIR osmpbf.h
+  HINTS
+  $ENV{OSMPBF_DIR}
+  PATH_SUFFIXES OSMPBF include/osmpbf include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local # DarwinPorts
+  /opt
+)
+
+FIND_LIBRARY(OSMPBF_LIBRARY
+  NAMES osmpbf
+  HINTS
+  $ENV{OSMPBF_DIR}
+  PATH_SUFFIXES lib64 lib
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local
+  /opt
+)
+
+INCLUDE(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set OSMPBF_FOUND to TRUE if
+# all listed variables are TRUE
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(OSMPBF  DEFAULT_MSG  OSMPBF_LIBRARY OSMPBF_INCLUDE_DIR)
+
+IF( NOT OSMPBF_FIND_QUIETLY )
+    IF( OSMPBF_FOUND )
+        MESSAGE(STATUS "Found OSMPBF: ${OSMPBF_LIBRARY}" )
+    ENDIF()
+ENDIF()
+
+#MARK_AS_ADVANCED(OSMPBF_INCLUDE_DIR OSMPBF_LIBRARIES OSMPBF_LIBRARY OSMPBF_LIBRARY_DBG) 

cmake/FindSTXXL.cmake

@@ -0,0 +1,51 @@
+# Locate STXXL library
+# This module defines
+#  STXXL_FOUND, if false, do not try to link to libstxxl
+#  STXXL_LIBRARY
+#  STXXL_INCLUDE_DIR, where to find stxxl.h
+#
+
+
+IF( NOT STXXL_FIND_QUIETLY )
+    MESSAGE(STATUS "Looking for STXXL...")
+ENDIF()
+
+FIND_PATH(STXXL_INCLUDE_DIR stxxl.h
+  HINTS
+  $ENV{STXXL_DIR}
+  PATH_SUFFIXES stxxl include/stxxl/stxxl include/stxxl include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local # DarwinPorts
+  /opt
+)
+
+FIND_LIBRARY(STXXL_LIBRARY
+  NAMES stxxl
+  HINTS
+  $ENV{STXXL_DIR}
+  PATH_SUFFIXES lib64 lib
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local
+  /opt
+)
+
+INCLUDE(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set STXXL_FOUND to TRUE if
+# all listed variables are TRUE
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(STXXL  DEFAULT_MSG  STXXL_LIBRARY STXXL_INCLUDE_DIR)
+
+IF( NOT STXXL_FIND_QUIETLY )
+    IF( STXXL_FOUND )
+        MESSAGE(STATUS "Found STXXL: ${STXXL_LIBRARY}" )
+    ENDIF()
+ENDIF()
+
+MARK_AS_ADVANCED(STXXL_INCLUDE_DIR STXXL_LIBRARY) 

cmake/GetGitRevisionDescription.cmake

@@ -0,0 +1,123 @@
+# - Returns a version string from Git
+#
+# These functions force a re-configure on each git commit so that you can
+# trust the values of the variables in your build system.
+#
+#  get_git_head_revision(<refspecvar> <hashvar> [<additional arguments to git describe> ...])
+#
+# Returns the refspec and sha hash of the current head revision
+#
+#  git_describe(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe on the source tree, and adjusting
+# the output so that it tests false if an error occurs.
+#
+#  git_get_exact_tag(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe --exact-match on the source tree,
+# and adjusting the output so that it tests false if there was no exact
+# matching tag.
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__get_git_revision_description)
+	return()
+endif()
+set(__get_git_revision_description YES)
+
+# We must run the following at "include" time, not at function call time,
+# to find the path to this module rather than the path to a calling list file
+get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
+
+function(get_git_head_revision _refspecvar _hashvar)
+	set(GIT_PARENT_DIR "${CMAKE_SOURCE_DIR}")
+	set(GIT_DIR "${GIT_PARENT_DIR}/.git")
+	while(NOT EXISTS "${GIT_DIR}")	# .git dir not found, search parent directories
+		set(GIT_PREVIOUS_PARENT "${GIT_PARENT_DIR}")
+		get_filename_component(GIT_PARENT_DIR ${GIT_PARENT_DIR} PATH)
+		if(GIT_PARENT_DIR STREQUAL GIT_PREVIOUS_PARENT)
+			# We have reached the root directory, we are not in git
+			set(${_refspecvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
+			set(${_hashvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
+			return()
+		endif()
+		set(GIT_DIR "${GIT_PARENT_DIR}/.git")
+	endwhile()
+	set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
+	if(NOT EXISTS "${GIT_DATA}")
+		file(MAKE_DIRECTORY "${GIT_DATA}")
+	endif()
+
+	if(NOT EXISTS "${GIT_DIR}/HEAD")
+		return()
+	endif()
+	set(HEAD_FILE "${GIT_DATA}/HEAD")
+	configure_file("${GIT_DIR}/HEAD" "${HEAD_FILE}" COPYONLY)
+
+	configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
+		"${GIT_DATA}/grabRef.cmake"
+		@ONLY)
+	include("${GIT_DATA}/grabRef.cmake")
+
+	set(${_refspecvar} "${HEAD_REF}" PARENT_SCOPE)
+	set(${_hashvar} "${HEAD_HASH}" PARENT_SCOPE)
+endfunction()
+
+function(git_describe _var)
+	if(NOT GIT_FOUND)
+		find_package(Git QUIET)
+	endif()
+	get_git_head_revision(refspec hash)
+	if(NOT GIT_FOUND)
+		set(${_var} "GIT-NOTFOUND" PARENT_SCOPE)
+		return()
+	endif()
+	if(NOT hash)
+		set(${_var} "HEAD-HASH-NOTFOUND" PARENT_SCOPE)
+		return()
+	endif()
+
+	# TODO sanitize
+	#if((${ARGN}" MATCHES "&&") OR
+	#	(ARGN MATCHES "||") OR
+	#	(ARGN MATCHES "\\;"))
+	#	message("Please report the following error to the project!")
+	#	message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
+	#endif()
+
+	#message(STATUS "Arguments to execute_process: ${ARGN}")
+
+	execute_process(COMMAND
+		"${GIT_EXECUTABLE}"
+		describe
+		${hash}
+		${ARGN}
+		WORKING_DIRECTORY
+		"${CMAKE_SOURCE_DIR}"
+		RESULT_VARIABLE
+		res
+		OUTPUT_VARIABLE
+		out
+		ERROR_QUIET
+		OUTPUT_STRIP_TRAILING_WHITESPACE)
+	if(NOT res EQUAL 0)
+		set(out "${out}-${res}-NOTFOUND")
+	endif()
+
+	set(${_var} "${out}" PARENT_SCOPE)
+endfunction()
+
+function(git_get_exact_tag _var)
+	git_describe(out --exact-match ${ARGN})
+	set(${_var} "${out}" PARENT_SCOPE)
+endfunction()

createHierarchy.cpp

@@ -18,15 +18,26 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 or see http://www.gnu.org/licenses/agpl.txt.
  */
 
-extern "C" {
-#include <lua.h>
-#include <lauxlib.h>
-#include <lualib.h>
-}
-#include <luabind/luabind.hpp>
+#include "Algorithms/IteratorBasedCRC32.h"
+#include "Contractor/Contractor.h"
+#include "Contractor/EdgeBasedGraphFactory.h"
+#include "DataStructures/BinaryHeap.h"
+#include "DataStructures/DeallocatingVector.h"
+#include "DataStructures/QueryEdge.h"
+#include "DataStructures/StaticGraph.h"
+#include "DataStructures/StaticRTree.h"
+#include "Util/BaseConfiguration.h"
+#include "Util/GraphLoader.h"
+#include "Util/InputFileUtil.h"
+#include "Util/LuaUtil.h"
+#include "Util/OpenMPWrapper.h"
+#include "Util/StringUtil.h"
+#include "typedefs.h"
 
 #include <boost/foreach.hpp>
 
+#include <luabind/luabind.hpp>
+
 #include <fstream>
 #include <istream>
 #include <iostream>
@@ -34,22 +45,6 @@ extern "C" {
 #include <string>
 #include <vector>
 
-#include "Algorithms/IteratorBasedCRC32.h"
-#include "Util/OpenMPWrapper.h"
-#include "typedefs.h"
-#include "Contractor/Contractor.h"
-#include "Contractor/EdgeBasedGraphFactory.h"
-#include "DataStructures/BinaryHeap.h"
-#include "DataStructures/DeallocatingVector.h"
-#include "DataStructures/NNGrid.h"
-#include "DataStructures/QueryEdge.h"
-#include "Util/BaseConfiguration.h"
-#include "Util/InputFileUtil.h"
-#include "Util/GraphLoader.h"
-#include "Util/StringUtil.h"
-
-using namespace std;
-
 typedef QueryEdge::EdgeData EdgeData;
 typedef DynamicGraph<EdgeData>::InputEdge InputEdge;
 typedef StaticGraph<EdgeData>::InputEdge StaticEdge;
@@ -59,216 +54,223 @@ std::vector<NodeInfo> internalToExternalNodeMapping;
 std::vector<_Restriction> inputRestrictions;
 std::vector<NodeID> bollardNodes;
 std::vector<NodeID> trafficLightNodes;
+std::vector<ImportEdge> edgeList;
 
 int main (int argc, char *argv[]) {
-    if(argc < 3) {
-        ERR("usage: " << std::endl << argv[0] << " <osrm-data> <osrm-restrictions> [<profile>]");
-    }
-
-    double startupTime = get_timestamp();
-    unsigned numberOfThreads = omp_get_num_procs();
-    if(testDataFile("contractor.ini")) {
-        ContractorConfiguration contractorConfig("contractor.ini");
-        unsigned rawNumber = stringToInt(contractorConfig.GetParameter("Threads"));
-        if(rawNumber != 0 && rawNumber <= numberOfThreads)
-            numberOfThreads = rawNumber;
-    }
-    omp_set_num_threads(numberOfThreads);
-
-    INFO("Using restrictions from file: " << argv[2]);
-    std::ifstream restrictionsInstream(argv[2], ios::binary);
-    if(!restrictionsInstream.good()) {
-        ERR("Could not access <osrm-restrictions> files");
-    }
-    _Restriction restriction;
-    unsigned usableRestrictionsCounter(0);
-    restrictionsInstream.read((char*)&usableRestrictionsCounter, sizeof(unsigned));
-    inputRestrictions.resize(usableRestrictionsCounter);
-    restrictionsInstream.read((char *)&(inputRestrictions[0]), usableRestrictionsCounter*sizeof(_Restriction));
-    restrictionsInstream.close();
-
-    std::ifstream in;
-    in.open (argv[1], std::ifstream::in | std::ifstream::binary);
-    if (!in.is_open()) {
-        ERR("Cannot open " << argv[1]);
-    }
-
-    char nodeOut[1024];         strcpy(nodeOut, argv[1]);           strcat(nodeOut, ".nodes");
-    char edgeOut[1024];         strcpy(edgeOut, argv[1]);           strcat(edgeOut, ".edges");
-    char graphOut[1024];    	strcpy(graphOut, argv[1]);      	strcat(graphOut, ".hsgr");
-    char ramIndexOut[1024];    	strcpy(ramIndexOut, argv[1]);    	strcat(ramIndexOut, ".ramIndex");
-    char fileIndexOut[1024];    strcpy(fileIndexOut, argv[1]);    	strcat(fileIndexOut, ".fileIndex");
-    char levelInfoOut[1024];    strcpy(levelInfoOut, argv[1]);    	strcat(levelInfoOut, ".levels");
-
-    /*** Setup Scripting Environment ***/
-    if(!testDataFile( (argc > 3 ? argv[3] : "profile.lua") )) {
-        ERR("Need profile.lua to apply traffic signal penalty");
-    }
-
-    // Create a new lua state
-    lua_State *myLuaState = luaL_newstate();
-
-    // Connect LuaBind to this lua state
-    luabind::open(myLuaState);
-
-
-    // Now call our function in a lua script
-    INFO("Parsing speedprofile from " << (argc > 3 ? argv[3] : "profile.lua") );
-    if(0 != luaL_dofile(myLuaState, (argc > 3 ? argv[3] : "profile.lua") )) {
-        ERR(lua_tostring(myLuaState,-1)<< " occured in scripting block");
-    }
-
-    EdgeBasedGraphFactory::SpeedProfileProperties speedProfile;
-
-    if(0 != luaL_dostring( myLuaState, "return traffic_signal_penalty\n")) {
-        ERR(lua_tostring(myLuaState,-1)<< " occured in scripting block");
-    }
-    speedProfile.trafficSignalPenalty = 10*lua_tointeger(myLuaState, -1);
-
-    if(0 != luaL_dostring( myLuaState, "return u_turn_penalty\n")) {
-        ERR(lua_tostring(myLuaState,-1)<< " occured in scripting block");
-    }
-    speedProfile.uTurnPenalty = 10*lua_tointeger(myLuaState, -1);
-
-
-    std::vector<ImportEdge> edgeList;
-    NodeID nodeBasedNodeNumber = readBinaryOSRMGraphFromStream(in, edgeList, bollardNodes, trafficLightNodes, &internalToExternalNodeMapping, inputRestrictions);
-    in.close();
-    INFO(inputRestrictions.size() << " restrictions, " << bollardNodes.size() << " bollard nodes, " << trafficLightNodes.size() << " traffic lights");
-    if(0 == edgeList.size())
-        ERR("The input data is broken. It is impossible to do any turns in this graph");
-
-
-    /***
-     * Building an edge-expanded graph from node-based input an turn restrictions
-     */
-
-    INFO("Generating edge-expanded graph representation");
-    EdgeBasedGraphFactory * edgeBasedGraphFactory = new EdgeBasedGraphFactory (nodeBasedNodeNumber, edgeList, bollardNodes, trafficLightNodes, inputRestrictions, internalToExternalNodeMapping, speedProfile);
-    std::vector<ImportEdge>().swap(edgeList);
-    edgeBasedGraphFactory->Run(edgeOut);
-    std::vector<_Restriction>().swap(inputRestrictions);
-    std::vector<NodeID>().swap(bollardNodes);
-    std::vector<NodeID>().swap(trafficLightNodes);
-    NodeID edgeBasedNodeNumber = edgeBasedGraphFactory->GetNumberOfNodes();
-    DeallocatingVector<EdgeBasedEdge> edgeBasedEdgeList;
-    edgeBasedGraphFactory->GetEdgeBasedEdges(edgeBasedEdgeList);
-
-    /***
-     * Writing info on original (node-based) nodes
-     */
-
-    INFO("writing node map ...");
-    std::ofstream mapOutFile(nodeOut, std::ios::binary);
-    mapOutFile.write((char *)&(internalToExternalNodeMapping[0]), internalToExternalNodeMapping.size()*sizeof(NodeInfo));
-    mapOutFile.close();
-    std::vector<NodeInfo>().swap(internalToExternalNodeMapping);
-
-    /***
-     * Writing info on original (node-based) edges
-     */
-    INFO("writing info on original edges");
-    std::vector<OriginalEdgeData> originalEdgeData;
-    edgeBasedGraphFactory->GetOriginalEdgeData(originalEdgeData);
-
-    DeallocatingVector<EdgeBasedGraphFactory::EdgeBasedNode> nodeBasedEdgeList;
-    edgeBasedGraphFactory->GetEdgeBasedNodes(nodeBasedEdgeList);
-    delete edgeBasedGraphFactory;
-    double expansionHasFinishedTime = get_timestamp() - startupTime;
-
-    /***
-     * Building grid-like nearest-neighbor data structure
-     */
-
-    INFO("building grid ...");
-    WritableGrid * writeableGrid = new WritableGrid();
-    writeableGrid->ConstructGrid(nodeBasedEdgeList, ramIndexOut, fileIndexOut);
-    delete writeableGrid;
-    IteratorbasedCRC32<DeallocatingVector<EdgeBasedGraphFactory::EdgeBasedNode> > crc32;
-    unsigned crc32OfNodeBasedEdgeList = crc32(nodeBasedEdgeList.begin(), nodeBasedEdgeList.end() );
-    nodeBasedEdgeList.clear();
-    INFO("CRC32 based checksum is " << crc32OfNodeBasedEdgeList);
-
-    /***
-     * Contracting the edge-expanded graph
-     */
-
-    INFO("initializing contractor");
-    Contractor* contractor = new Contractor( edgeBasedNodeNumber, edgeBasedEdgeList );
-    double contractionStartedTimestamp(get_timestamp());
-    contractor->Run();
-    INFO("Contraction took " << get_timestamp() - contractionStartedTimestamp << " sec");
-
-    DeallocatingVector< QueryEdge > contractedEdgeList;
-    contractor->GetEdges( contractedEdgeList );
-    delete contractor;
-
-    /***
-     * Sorting contracted edges in a way that the static query graph can read some in in-place.
-     */
-
-    INFO("Building Node Array");
-    sort(contractedEdgeList.begin(), contractedEdgeList.end());
-    unsigned numberOfNodes = 0;
-    unsigned numberOfEdges = contractedEdgeList.size();
-    INFO("Serializing compacted graph");
-    ofstream edgeOutFile(graphOut, ios::binary);
-
-    BOOST_FOREACH(QueryEdge & edge, contractedEdgeList) {
-        if(edge.source > numberOfNodes) {
-            numberOfNodes = edge.source;
+    try {
+        if(argc < 3) {
+            ERR("usage: " << std::endl << argv[0] << " <osrm-data> <osrm-restrictions> [<profile>]");
         }
-        if(edge.target > numberOfNodes) {
-            numberOfNodes = edge.target;
+
+        double startupTime = get_timestamp();
+        unsigned numberOfThreads = omp_get_num_procs();
+        if(testDataFile("contractor.ini")) {
+            ContractorConfiguration contractorConfig("contractor.ini");
+            unsigned rawNumber = stringToInt(contractorConfig.GetParameter("Threads"));
+            if(rawNumber != 0 && rawNumber <= numberOfThreads)
+                numberOfThreads = rawNumber;
         }
-    }
-    numberOfNodes+=1;
+        omp_set_num_threads(numberOfThreads);
 
-    std::vector< StaticGraph<EdgeData>::_StrNode > _nodes;
-    _nodes.resize( numberOfNodes + 1 );
+        INFO("Using restrictions from file: " << argv[2]);
+        std::ifstream restrictionsInstream(argv[2], std::ios::binary);
+        if(!restrictionsInstream.good()) {
+            ERR("Could not access <osrm-restrictions> files");
+        }
+        _Restriction restriction;
+        unsigned usableRestrictionsCounter(0);
+        restrictionsInstream.read((char*)&usableRestrictionsCounter, sizeof(unsigned));
+        inputRestrictions.resize(usableRestrictionsCounter);
+        restrictionsInstream.read((char *)&(inputRestrictions[0]), usableRestrictionsCounter*sizeof(_Restriction));
+        restrictionsInstream.close();
 
-    StaticGraph<EdgeData>::EdgeIterator edge = 0;
-    StaticGraph<EdgeData>::EdgeIterator position = 0;
-    for ( StaticGraph<EdgeData>::NodeIterator node = 0; node <= numberOfNodes; ++node ) {
-        StaticGraph<EdgeData>::EdgeIterator lastEdge = edge;
-        while ( edge < numberOfEdges && contractedEdgeList[edge].source == node )
-            ++edge;
-        _nodes[node].firstEdge = position; //=edge
-        position += edge - lastEdge; //remove
-    }
-    ++numberOfNodes;
-    //Serialize numberOfNodes, nodes
-    edgeOutFile.write((char*) &crc32OfNodeBasedEdgeList, sizeof(unsigned));
-    edgeOutFile.write((char*) &numberOfNodes, sizeof(unsigned));
-    edgeOutFile.write((char*) &_nodes[0], sizeof(StaticGraph<EdgeData>::_StrNode)*(numberOfNodes));
-    //Serialize number of Edges
-    edgeOutFile.write((char*) &position, sizeof(unsigned));
-    --numberOfNodes;
-    edge = 0;
-    int usedEdgeCounter = 0;
-    StaticGraph<EdgeData>::_StrEdge currentEdge;
-    for ( StaticGraph<EdgeData>::NodeIterator node = 0; node < numberOfNodes; ++node ) {
-        for ( StaticGraph<EdgeData>::EdgeIterator i = _nodes[node].firstEdge, e = _nodes[node+1].firstEdge; i != e; ++i ) {
-            assert(node != contractedEdgeList[edge].target);
-            currentEdge.target = contractedEdgeList[edge].target;
-            currentEdge.data = contractedEdgeList[edge].data;
-            if(currentEdge.data.distance <= 0) {
-                INFO("Edge: " << i << ",source: " << contractedEdgeList[edge].source << ", target: " << contractedEdgeList[edge].target << ", dist: " << currentEdge.data.distance);
-                ERR("Failed at edges of node " << node << " of " << numberOfNodes);
+        std::ifstream in;
+        in.open (argv[1], std::ifstream::in | std::ifstream::binary);
+        if (!in.is_open()) {
+            ERR("Cannot open " << argv[1]);
+        }
+
+        std::string nodeOut(argv[1]);		nodeOut += ".nodes";
+        std::string edgeOut(argv[1]);		edgeOut += ".edges";
+        std::string graphOut(argv[1]);		graphOut += ".hsgr";
+        std::string rtree_nodes_path(argv[1]);  rtree_nodes_path += ".ramIndex";
+        std::string rtree_leafs_path(argv[1]);  rtree_leafs_path += ".fileIndex";
+
+        /*** Setup Scripting Environment ***/
+        if(!testDataFile( (argc > 3 ? argv[3] : "profile.lua") )) {
+            ERR("Need profile.lua to apply traffic signal penalty");
+        }
+
+        // Create a new lua state
+        lua_State *myLuaState = luaL_newstate();
+
+        // Connect LuaBind to this lua state
+        luabind::open(myLuaState);
+
+        //open utility libraries string library;
+        luaL_openlibs(myLuaState);
+
+        //adjust lua load path
+        luaAddScriptFolderToLoadPath( myLuaState, (argc > 3 ? argv[3] : "profile.lua") );
+
+        // Now call our function in a lua script
+        INFO("Parsing speedprofile from " << (argc > 3 ? argv[3] : "profile.lua") );
+        if(0 != luaL_dofile(myLuaState, (argc > 3 ? argv[3] : "profile.lua") )) {
+            ERR(lua_tostring(myLuaState,-1)<< " occured in scripting block");
+        }
+
+        EdgeBasedGraphFactory::SpeedProfileProperties speedProfile;
+
+        if(0 != luaL_dostring( myLuaState, "return traffic_signal_penalty\n")) {
+            ERR(lua_tostring(myLuaState,-1)<< " occured in scripting block");
+        }
+        speedProfile.trafficSignalPenalty = 10*lua_tointeger(myLuaState, -1);
+
+        if(0 != luaL_dostring( myLuaState, "return u_turn_penalty\n")) {
+            ERR(lua_tostring(myLuaState,-1)<< " occured in scripting block");
+        }
+        speedProfile.uTurnPenalty = 10*lua_tointeger(myLuaState, -1);
+
+        speedProfile.has_turn_penalty_function = lua_function_exists( myLuaState, "turn_function" );
+
+        std::vector<ImportEdge> edgeList;
+        NodeID nodeBasedNodeNumber = readBinaryOSRMGraphFromStream(in, edgeList, bollardNodes, trafficLightNodes, &internalToExternalNodeMapping, inputRestrictions);
+        in.close();
+        INFO(inputRestrictions.size() << " restrictions, " << bollardNodes.size() << " bollard nodes, " << trafficLightNodes.size() << " traffic lights");
+        if(0 == edgeList.size())
+            ERR("The input data is broken. It is impossible to do any turns in this graph");
+
+
+        /***
+         * Building an edge-expanded graph from node-based input an turn restrictions
+         */
+
+        INFO("Generating edge-expanded graph representation");
+        EdgeBasedGraphFactory * edgeBasedGraphFactory = new EdgeBasedGraphFactory (nodeBasedNodeNumber, edgeList, bollardNodes, trafficLightNodes, inputRestrictions, internalToExternalNodeMapping, speedProfile);
+        std::vector<ImportEdge>().swap(edgeList);
+        edgeBasedGraphFactory->Run(edgeOut.c_str(), myLuaState);
+        std::vector<_Restriction>().swap(inputRestrictions);
+        std::vector<NodeID>().swap(bollardNodes);
+        std::vector<NodeID>().swap(trafficLightNodes);
+        NodeID edgeBasedNodeNumber = edgeBasedGraphFactory->GetNumberOfNodes();
+        DeallocatingVector<EdgeBasedEdge> edgeBasedEdgeList;
+        edgeBasedGraphFactory->GetEdgeBasedEdges(edgeBasedEdgeList);
+        std::vector<EdgeBasedGraphFactory::EdgeBasedNode> nodeBasedEdgeList;
+        edgeBasedGraphFactory->GetEdgeBasedNodes(nodeBasedEdgeList);
+        delete edgeBasedGraphFactory;
+
+        /***
+         * Writing info on original (node-based) nodes
+         */
+
+        INFO("writing node map ...");
+        std::ofstream mapOutFile(nodeOut.c_str(), std::ios::binary);
+        mapOutFile.write((char *)&(internalToExternalNodeMapping[0]), internalToExternalNodeMapping.size()*sizeof(NodeInfo));
+        mapOutFile.close();
+        std::vector<NodeInfo>().swap(internalToExternalNodeMapping);
+
+        double expansionHasFinishedTime = get_timestamp() - startupTime;
+
+        /***
+         * Building grid-like nearest-neighbor data structure
+         */
+
+        INFO("building r-tree ...");
+        StaticRTree<EdgeBasedGraphFactory::EdgeBasedNode> * rtree =
+                new StaticRTree<EdgeBasedGraphFactory::EdgeBasedNode>(
+                        nodeBasedEdgeList,
+                        rtree_nodes_path.c_str(),
+                        rtree_leafs_path.c_str()
+                );
+        delete rtree;
+        IteratorbasedCRC32<std::vector<EdgeBasedGraphFactory::EdgeBasedNode> > crc32;
+        unsigned crc32OfNodeBasedEdgeList = crc32(nodeBasedEdgeList.begin(), nodeBasedEdgeList.end() );
+        nodeBasedEdgeList.clear();
+        INFO("CRC32 based checksum is " << crc32OfNodeBasedEdgeList);
+
+        /***
+         * Contracting the edge-expanded graph
+         */
+
+        INFO("initializing contractor");
+        Contractor* contractor = new Contractor( edgeBasedNodeNumber, edgeBasedEdgeList );
+        double contractionStartedTimestamp(get_timestamp());
+        contractor->Run();
+        INFO("Contraction took " << get_timestamp() - contractionStartedTimestamp << " sec");
+
+        DeallocatingVector< QueryEdge > contractedEdgeList;
+        contractor->GetEdges( contractedEdgeList );
+        delete contractor;
+
+        /***
+         * Sorting contracted edges in a way that the static query graph can read some in in-place.
+         */
+
+        INFO("Building Node Array");
+        std::sort(contractedEdgeList.begin(), contractedEdgeList.end());
+        unsigned numberOfNodes = 0;
+        unsigned numberOfEdges = contractedEdgeList.size();
+        INFO("Serializing compacted graph of " << numberOfEdges << " edges");
+        std::ofstream edgeOutFile(graphOut.c_str(), std::ios::binary);
+
+        BOOST_FOREACH(const QueryEdge & edge, contractedEdgeList) {
+            if(edge.source > numberOfNodes) {
+                numberOfNodes = edge.source;
+            }
+            if(edge.target > numberOfNodes) {
+                numberOfNodes = edge.target;
             }
-            //Serialize edges
-            edgeOutFile.write((char*) &currentEdge, sizeof(StaticGraph<EdgeData>::_StrEdge));
-            ++edge;
-            ++usedEdgeCounter;
         }
-    }
-    double endTime = (get_timestamp() - startupTime);
-    INFO("Expansion  : " << (nodeBasedNodeNumber/expansionHasFinishedTime) << " nodes/sec and "<< (edgeBasedNodeNumber/expansionHasFinishedTime) << " edges/sec");
-    INFO("Contraction: " << (edgeBasedNodeNumber/expansionHasFinishedTime) << " nodes/sec and "<< usedEdgeCounter/endTime << " edges/sec");
+        numberOfNodes+=1;
 
-    edgeOutFile.close();
-    //cleanedEdgeList.clear();
-    _nodes.clear();
-    INFO("finished preprocessing");
+        std::vector< StaticGraph<EdgeData>::_StrNode > _nodes;
+        _nodes.resize( numberOfNodes + 1 );
+
+        StaticGraph<EdgeData>::EdgeIterator edge = 0;
+        StaticGraph<EdgeData>::EdgeIterator position = 0;
+        for ( StaticGraph<EdgeData>::NodeIterator node = 0; node <= numberOfNodes; ++node ) {
+            StaticGraph<EdgeData>::EdgeIterator lastEdge = edge;
+            while ( edge < numberOfEdges && contractedEdgeList[edge].source == node )
+                ++edge;
+            _nodes[node].firstEdge = position; //=edge
+            position += edge - lastEdge; //remove
+        }
+        ++numberOfNodes;
+        //Serialize numberOfNodes, nodes
+        edgeOutFile.write((char*) &crc32OfNodeBasedEdgeList, sizeof(unsigned));
+        edgeOutFile.write((char*) &numberOfNodes, sizeof(unsigned));
+        edgeOutFile.write((char*) &_nodes[0], sizeof(StaticGraph<EdgeData>::_StrNode)*(numberOfNodes));
+        //Serialize number of Edges
+        edgeOutFile.write((char*) &position, sizeof(unsigned));
+        --numberOfNodes;
+        edge = 0;
+        int usedEdgeCounter = 0;
+        StaticGraph<EdgeData>::_StrEdge currentEdge;
+        for ( StaticGraph<EdgeData>::NodeIterator node = 0; node < numberOfNodes; ++node ) {
+            for ( StaticGraph<EdgeData>::EdgeIterator i = _nodes[node].firstEdge, e = _nodes[node+1].firstEdge; i != e; ++i ) {
+                assert(node != contractedEdgeList[edge].target);
+                currentEdge.target = contractedEdgeList[edge].target;
+                currentEdge.data = contractedEdgeList[edge].data;
+                if(currentEdge.data.distance <= 0) {
+                    INFO("Edge: " << i << ",source: " << contractedEdgeList[edge].source << ", target: " << contractedEdgeList[edge].target << ", dist: " << currentEdge.data.distance);
+                    ERR("Failed at edges of node " << node << " of " << numberOfNodes);
+                }
+                //Serialize edges
+                edgeOutFile.write((char*) &currentEdge, sizeof(StaticGraph<EdgeData>::_StrEdge));
+                ++edge;
+                ++usedEdgeCounter;
+            }
+        }
+        double endTime = (get_timestamp() - startupTime);
+        INFO("Expansion  : " << (nodeBasedNodeNumber/expansionHasFinishedTime) << " nodes/sec and "<< (edgeBasedNodeNumber/expansionHasFinishedTime) << " edges/sec");
+        INFO("Contraction: " << (edgeBasedNodeNumber/expansionHasFinishedTime) << " nodes/sec and "<< usedEdgeCounter/endTime << " edges/sec");
+
+        edgeOutFile.close();
+        //cleanedEdgeList.clear();
+        _nodes.clear();
+        INFO("finished preprocessing");
+    } catch (std::exception &e) {
+        ERR("Exception occured: " << e.what());
+    }
     return 0;
 }

extractor.cpp

@@ -18,12 +18,6 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 or see http://www.gnu.org/licenses/agpl.txt.
  */
 
-#include <cstdlib>
-#include <iostream>
-#include <fstream>
-#include <string>
-
-#include "typedefs.h"
 #include "Extractor/ExtractorCallbacks.h"
 #include "Extractor/ExtractionContainers.h"
 #include "Extractor/ScriptingEnvironment.h"
@@ -32,13 +26,23 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include "Util/BaseConfiguration.h"
 #include "Util/InputFileUtil.h"
 #include "Util/MachineInfo.h"
+#include "Util/OpenMPWrapper.h"
 #include "Util/StringUtil.h"
+#include "typedefs.h"
+
+#include <cstdlib>
+#include <iostream>
+#include <fstream>
+
+#include <string>
 
 typedef BaseConfiguration ExtractorConfiguration;
 
 ExtractorCallbacks * extractCallBacks;
 
 int main (int argc, char *argv[]) {
+    double earliestTime = get_timestamp();
+
     if(argc < 2) {
         ERR("usage: \n" << argv[0] << " <file.osm/.osm.bz2/.osm.pbf> [<profile.lua>]");
     }
@@ -55,7 +59,6 @@ int main (int argc, char *argv[]) {
     }
     omp_set_num_threads(numberOfThreads);
 
-
     INFO("extracting data from input file " << argv[1]);
     bool isPBF(false);
     std::string outputFileName(argv[1]);
@@ -67,12 +70,12 @@ int main (int argc, char *argv[]) {
             isPBF = true;
         }
     }
-    if(pos!=string::npos) {
+    if(pos!=std::string::npos) {
         outputFileName.replace(pos, 8, ".osrm");
         restrictionsFileName.replace(pos, 8, ".osrm.restrictions");
     } else {
         pos=outputFileName.find(".osm");
-        if(pos!=string::npos) {
+        if(pos!=std::string::npos) {
             outputFileName.replace(pos, 5, ".osrm");
             restrictionsFileName.replace(pos, 5, ".osrm.restrictions");
         } else {
@@ -82,38 +85,38 @@ int main (int argc, char *argv[]) {
     }
 
     unsigned amountOfRAM = 1;
-    unsigned installedRAM = GetPhysicalmemory(); 
+    unsigned installedRAM = GetPhysicalmemory();
     if(installedRAM < 2048264) {
         WARN("Machine has less than 2GB RAM.");
     }
-	
+
     StringMap stringMap;
     ExtractionContainers externalMemory;
 
-
     stringMap[""] = 0;
     extractCallBacks = new ExtractorCallbacks(&externalMemory, &stringMap);
-    BaseParser<ExtractorCallbacks, _Node, _RawRestrictionContainer, _Way> * parser;
+    BaseParser* parser;
     if(isPBF) {
-        parser = new PBFParser(argv[1]);
+        parser = new PBFParser(argv[1], extractCallBacks, scriptingEnvironment);
     } else {
-        parser = new XMLParser(argv[1]);
+        parser = new XMLParser(argv[1], extractCallBacks, scriptingEnvironment);
     }
-    parser->RegisterCallbacks(extractCallBacks);
-    parser->RegisterScriptingEnvironment(scriptingEnvironment);
 
-    if(!parser->Init())
+    if(!parser->ReadHeader()) {
         ERR("Parser not initialized!");
+    }
+    INFO("Parsing in progress..");
     double time = get_timestamp();
     parser->Parse();
-    INFO("parsing finished after " << get_timestamp() - time << " seconds");
+    INFO("Parsing finished after " << get_timestamp() - time << " seconds");
 
     externalMemory.PrepareData(outputFileName, restrictionsFileName, amountOfRAM);
 
     stringMap.clear();
     delete parser;
     delete extractCallBacks;
-    INFO("finished");
+    INFO("finished after " << get_timestamp() - earliestTime << "s");
+
     std::cout << "\nRun:\n"
                    "./osrm-prepare " << outputFileName << " " << restrictionsFileName << std::endl;
     return 0;

features/bicycle/access.feature

@@ -1,5 +1,5 @@
 @routing @bicycle @access
-Feature: Bike - Restricted access
+Feature: Bike - Access tags on ways
 Reference: http://wiki.openstreetmap.org/wiki/Key:access
 
 	Background:
@@ -7,37 +7,95 @@ Reference: http://wiki.openstreetmap.org/wiki/Key:access
 		
 	Scenario: Bike - Access tag hierachy on ways
 		Then routability should be
-		 | access | vehicle | bicycle | bothw |
-		 |        |         |         | x     |
-		 | yes    |         |         | x     |
-		 | no     |         |         |       |
-		 |        | yes     |         | x     |
-		 |        | no      |         |       |
-		 | no     | yes     |         | x     |
-		 | yes    | no      |         |       |
-		 |        |         | yes     | x     |
-		 |        |         | no      |       |
-		 | no     |         | yes     | x     |
-		 | yes    |         | no      |       |
-		 |        | no      | yes     | x     |
-		 |        | yes     | no      |       |
+		 | highway | access | vehicle | bicycle | bothw |
+		 |         |        |         |         | x     |
+		 |         | yes    |         |         | x     |
+		 |         | no     |         |         |       |
+		 |         |        | yes     |         | x     |
+		 |         |        | no      |         |       |
+		 |         | no     | yes     |         | x     |
+		 |         | yes    | no      |         |       |
+		 |         |        |         | yes     | x     |
+		 |         |        |         | no      |       |
+		 |         | no     |         | yes     | x     |
+		 |         | yes    |         | no      |       |
+		 |         |        | no      | yes     | x     |
+		 |         |        | yes     | no      |       |
+		 | runway  |        |         |         |       |
+		 | runway  | yes    |         |         | x     |
+		 | runway  | no     |         |         |       |
+		 | runway  |        | yes     |         | x     |
+		 | runway  |        | no      |         |       |
+		 | runway  | no     | yes     |         | x     |
+		 | runway  | yes    | no      |         |       |
+		 | runway  |        |         | yes     | x     |
+		 | runway  |        |         | no      |       |
+		 | runway  | no     |         | yes     | x     |
+		 | runway  | yes    |         | no      |       |
+		 | runway  |        | no      | yes     | x     |
+		 | runway  |        | yes     | no      |       |
 
-	Scenario: Bike - Access tag hierachy on nodes
-		Then routability should be
-		 | node/access | node/vehicle | node/bicycle | bothw |
-		 |             |              |              | x     |
-		 | yes         |              |              | x     |
-		 | no          |              |              |       |
-		 |             | yes          |              | x     |
-		 |             | no           |              |       |
-		 | no          | yes          |              | x     |
-		 | yes         | no           |              |       |
-		 |             |              | yes          | x     |
-		 |             |              | no           |       |
-		 | no          |              | yes          | x     |
-		 | yes         |              | no           |       |
-		 |             | no           | yes          | x     |
-		 |             | yes          | no           |       |
+    @todo
+  	Scenario: Bike - Access tag in forward direction
+  		Then routability should be
+  		 | highway | access:forward | vehicle:forward | bicycle:forward | forw | backw |
+  		 |         |                |                 |                 | x    |       |
+  		 |         | yes            |                 |                 | x    |       |
+  		 |         | no             |                 |                 |      |       |
+  		 |         |                | yes             |                 | x    |       |
+  		 |         |                | no              |                 |      |       |
+  		 |         | no             | yes             |                 | x    |       |
+  		 |         | yes            | no              |                 |      |       |
+  		 |         |                |                 | yes             | x    |       |
+  		 |         |                |                 | no              |      |       |
+  		 |         | no             |                 | yes             | x    |       |
+  		 |         | yes            |                 | no              |      |       |
+  		 |         |                | no              | yes             | x    |       |
+  		 |         |                | yes             | no              |      |       |
+  		 | runway  |                |                 |                 | x    |       |
+  		 | runway  | yes            |                 |                 | x    |       |
+  		 | runway  | no             |                 |                 |      |       |
+  		 | runway  |                | yes             |                 | x    |       |
+  		 | runway  |                | no              |                 |      |       |
+  		 | runway  | no             | yes             |                 | x    |       |
+  		 | runway  | yes            | no              |                 |      |       |
+  		 | runway  |                |                 | yes             | x    |       |
+  		 | runway  |                |                 | no              |      |       |
+  		 | runway  | no             |                 | yes             | x    |       |
+  		 | runway  | yes            |                 | no              |      |       |
+  		 | runway  |                | no              | yes             | x    |       |
+  		 | runway  |                | yes             | no              |      |       |
+
+    @todo
+   	Scenario: Bike - Access tag in backward direction
+   		Then routability should be
+   		 | highway | access:forward | vehicle:forward | bicycle:forward | forw | backw |
+   		 |         |                |                 |                 |      | x     |
+   		 |         | yes            |                 |                 |      | x     |
+   		 |         | no             |                 |                 |      |       |
+   		 |         |                | yes             |                 |      | x     |
+   		 |         |                | no              |                 |      |       |
+   		 |         | no             | yes             |                 |      | x     |
+   		 |         | yes            | no              |                 |      |       |
+   		 |         |                |                 | yes             |      | x     |
+   		 |         |                |                 | no              |      |       |
+   		 |         | no             |                 | yes             |      | x     |
+   		 |         | yes            |                 | no              |      |       |
+   		 |         |                | no              | yes             |      | x     |
+   		 |         |                | yes             | no              |      |       |
+   		 | runway  |                |                 |                 |      | x     |
+   		 | runway  | yes            |                 |                 |      | x     |
+   		 | runway  | no             |                 |                 |      |       |
+   		 | runway  |                | yes             |                 |      | x     |
+   		 | runway  |                | no              |                 |      |       |
+   		 | runway  | no             | yes             |                 |      | x     |
+   		 | runway  | yes            | no              |                 |      |       |
+   		 | runway  |                |                 | yes             |      | x     |
+   		 | runway  |                |                 | no              |      |       |
+   		 | runway  | no             |                 | yes             |      | x     |
+   		 | runway  | yes            |                 | no              |      |       |
+   		 | runway  |                | no              | yes             |      | x     |
+   		 | runway  |                | yes             | no              |      |       |
 
 	Scenario: Bike - Overwriting implied acccess on ways
 		Then routability should be
@@ -51,18 +109,6 @@ Reference: http://wiki.openstreetmap.org/wiki/Key:access
 		 | runway   |        | yes     |         | x     |
 		 | runway   |        |         | yes     | x     |
 
-	Scenario: Bike - Overwriting implied acccess on nodes
-		Then routability should be
-		 | highway  | node/access | node/vehicle | node/bicycle | bothw |
-		 | cycleway |             |              |              | x     |
-		 | runway   |             |              |              |       |
-		 | cycleway | no          |              |              |       |
-		 | cycleway |             | no           |              |       |
-		 | cycleway |             |              | no           |       |
-		 | runway   | yes         |              |              |       |
-		 | runway   |             | yes          |              |       |
-		 | runway   |             |              | yes          |       |
-
 	Scenario: Bike - Access tags on ways
 	 	Then routability should be
 		 | access       | vehicle      | bicycle      | bothw |
@@ -92,35 +138,6 @@ Reference: http://wiki.openstreetmap.org/wiki/Key:access
 		 |              |              | agricultural |       |
 		 |              |              | forestery    |       |
 
-	Scenario: Bike - Access tags on nodes
-	 	Then routability should be
-		 | node/access  | node/vehicle | node/bicycle | bothw |
-		 |              |              |              | x     |
-		 | yes          |              |              | x     |
-		 | permissive   |              |              | x     |
-		 | designated   |              |              | x     |
-		 | some_tag     |              |              | x     |
-		 | no           |              |              |       |
-		 | private      |              |              |       |
-		 | agricultural |              |              |       |
-		 | forestery    |              |              |       |
-		 |              | yes          |              | x     |
-		 |              | permissive   |              | x     |
-		 |              | designated   |              | x     |
-		 |              | some_tag     |              | x     |
-		 |              | no           |              |       |
-		 |              | private      |              |       |
-		 |              | agricultural |              |       |
-		 |              | forestery    |              |       |
-		 |              |              | yes          | x     |
-		 |              |              | permissive   | x     |
-		 |              |              | designated   | x     |
-		 |              |              | some_tag     | x     |
-		 |              |              | no           |       |
-		 |              |              | private      |       |
-		 |              |              | agricultural |       |
-		 |              |              | forestery    |       |
-
 	Scenario: Bike - Access tags on both node and way
 	 	Then routability should be
 		 | access   | node/access | bothw |
@@ -147,10 +164,10 @@ Reference: http://wiki.openstreetmap.org/wiki/Key:access
 
 	Scenario: Bike - Ignore access tags for other modes
 	 	Then routability should be
-		 | highway  | foot | motor_vehicle | moped | bothw |
-		 | runway   | yes  |               |       |       |
+		 | highway  | boat | motor_vehicle | moped | bothw |
+		 | river    | yes  |               |       |       |
 		 | cycleway | no   |               |       | x     |
 		 | runway   |      | yes           |       |       |
 		 | cycleway |      | no            |       | x     |
 		 | runway   |      |               | yes   |       |
-		 | cycleway |      |               | no    | x     |
+		 | cycleway |      |               | no    | x     |

features/bicycle/access_node.feature

@@ -0,0 +1,64 @@
+@routing @bicycle @access
+Feature: Bike - Access tags on nodes
+Reference: http://wiki.openstreetmap.org/wiki/Key:access
+
+	Background:
+		Given the profile "bicycle"
+
+	Scenario: Bike - Access tag hierachy on nodes
+		Then routability should be
+		 | node/access | node/vehicle | node/bicycle | bothw |
+		 |             |              |              | x     |
+		 | yes         |              |              | x     |
+		 | no          |              |              |       |
+		 |             | yes          |              | x     |
+		 |             | no           |              |       |
+		 | no          | yes          |              | x     |
+		 | yes         | no           |              |       |
+		 |             |              | yes          | x     |
+		 |             |              | no           |       |
+		 | no          |              | yes          | x     |
+		 | yes         |              | no           |       |
+		 |             | no           | yes          | x     |
+		 |             | yes          | no           |       |
+
+	Scenario: Bike - Overwriting implied acccess on nodes
+		Then routability should be
+		 | highway  | node/access | node/vehicle | node/bicycle | bothw |
+		 | cycleway |             |              |              | x     |
+		 | runway   |             |              |              |       |
+		 | cycleway | no          |              |              |       |
+		 | cycleway |             | no           |              |       |
+		 | cycleway |             |              | no           |       |
+		 | runway   | yes         |              |              |       |
+		 | runway   |             | yes          |              |       |
+		 | runway   |             |              | yes          |       |
+
+	Scenario: Bike - Access tags on nodes
+	 	Then routability should be
+		 | node/access  | node/vehicle | node/bicycle | bothw |
+		 |              |              |              | x     |
+		 | yes          |              |              | x     |
+		 | permissive   |              |              | x     |
+		 | designated   |              |              | x     |
+		 | some_tag     |              |              | x     |
+		 | no           |              |              |       |
+		 | private      |              |              |       |
+		 | agricultural |              |              |       |
+		 | forestery    |              |              |       |
+		 |              | yes          |              | x     |
+		 |              | permissive   |              | x     |
+		 |              | designated   |              | x     |
+		 |              | some_tag     |              | x     |
+		 |              | no           |              |       |
+		 |              | private      |              |       |
+		 |              | agricultural |              |       |
+		 |              | forestery    |              |       |
+		 |              |              | yes          | x     |
+		 |              |              | permissive   | x     |
+		 |              |              | designated   | x     |
+		 |              |              | some_tag     | x     |
+		 |              |              | no           |       |
+		 |              |              | private      |       |
+		 |              |              | agricultural |       |
+		 |              |              | forestery    |       |

features/bicycle/area.feature

@@ -41,14 +41,14 @@ Feature: Bike - Squares and other areas
 
 		When I route I should get
 		 | from | to | route |
-		 | a    | b  |       |
-		 | a    | d  |       |
-		 | b    | c  |       |
-		 | c    | b  |       |
-		 | c    | d  |       |
-		 | d    | c  |       |
-		 | d    | a  |       |
-		 | a    | d  |       |
+		 | a    | b  | xa    |
+		 | a    | d  | xa    |
+		 | b    | c  | xa    |
+		 | c    | b  | xa    |
+		 | c    | d  | xa    |
+		 | d    | c  | xa    |
+		 | d    | a  | xa    |
+		 | a    | d  | xa    |
 	
 	@parking
 	Scenario: Bike - parking areas
@@ -100,4 +100,4 @@ Feature: Bike - Squares and other areas
 		 | c    | d  | abcda       |
 		 | d    | c  | abcda       |
 		 | d    | a  | abcda       |
-		 | a    | d  | abcda       |
+		 | a    | d  | abcda       |

features/bicycle/cycleway.feature

@@ -29,16 +29,16 @@ Reference: http://wiki.openstreetmap.org/wiki/Key:cycleway
 	 	Then routability should be
 		 | highway | cycleway | cycleway:left | cycleway:right | forw | backw |
 		 | primary |          |               |                | x    | x     |
-		 | pirmary | track    |               |                | x    | x     |
-		 | pirmary | opposite |               |                | x    | x     |
-		 | pirmary |          | track         |                | x    | x     |
-		 | pirmary |          | opposite      |                | x    | x     |
-		 | pirmary |          |               | track          | x    | x     |
-		 | pirmary |          |               | opposite       | x    | x     |
-		 | pirmary |          | track         | track          | x    | x     |
-		 | pirmary |          | opposite      | opposite       | x    | x     |
-		 | pirmary |          | track         | opposite       | x    | x     |
-		 | pirmary |          | opposite      | track          | x    | x     |
+		 | primary | track    |               |                | x    | x     |
+		 | primary | opposite |               |                | x    | x     |
+		 | primary |          | track         |                | x    | x     |
+		 | primary |          | opposite      |                | x    | x     |
+		 | primary |          |               | track          | x    | x     |
+		 | primary |          |               | opposite       | x    | x     |
+		 | primary |          | track         | track          | x    | x     |
+		 | primary |          | opposite      | opposite       | x    | x     |
+		 | primary |          | track         | opposite       | x    | x     |
+		 | primary |          | opposite      | track          | x    | x     |
 
 	Scenario: Bike - Left/right side cycleways on implied oneways   
 	 	Then routability should be

features/bicycle/ferry.feature

@@ -58,79 +58,6 @@ Feature: Bike - Handle ferry routes
 		 | abcd  |         | ferry | yes     | 1:00     |
 
 		When I route I should get
-		 | from | to | route | time      |
-		 | a    | d  | abcd  | 3600s +-1 |
-		 | d    | a  | abcd  | 3600s +-1 |
-
-	Scenario: Bike - Ferry duration, connected routes
-		Given the node map
-		  | x |   |   |   |   |   |   |   | y |
-		  |   | a | b | c | d | e | f | g |   |
-
-		And the ways
-		 | nodes | highway | route | bicycle | duration |
-		 | xa    | primary |       |         |          |
-		 | yg    | primary |       |         |          |
-		 | abcd  |         | ferry | yes     | 0:30     |
-		 | defg  |         | ferry | yes     | 0:30     |
-
-		When I route I should get
-		 | from | to | route     | time      |
-		 | a    | g  | abcd,defg | 3600s +-1 |
-		 | g    | a  | defg,abcd | 3600s +-1 |
-
-	Scenario: Bike - Prefer road when faster than ferry
-		Given the node map
-		  | x | a | b | c |   |
-		  |   |   |   |   | d |
-		  | y | g | f | e |   |
-		
-		And the ways
-		 | nodes | highway | route | bicycle | duration |
-		 | xa    | primary |       |         |          |
-		 | yg    | primary |       |         |          |
-		 | xy    | primary |       |         |          |
-		 | abcd  |         | ferry | yes     | 0:01     |
-		 | defg  |         | ferry | yes     | 0:01     |
-
-		When I route I should get
-		 | from | to | route    | time      |
-		 | a    | g  | xa,xy,yg | 60s +-25% |
-		 | g    | a  | yg,xy,xa | 60s +-25% |
-
-	Scenario: Bike - Long winding ferry route
-		Given the node map
-		  | x |   | b |   | d |   | f |   | y |
-		  |   | a |   | c |   | e |   | g |   |
-
-		And the ways
-		 | nodes   | highway | route | bicycle | duration |
-		 | xa      | primary |       |         |          |
-		 | yg      | primary |       |         |          |
-		 | abcdefg |         | ferry | yes     | 6:30     |
-
-		When I route I should get
-		 | from | to | route   | time       |
-		 | a    | g  | abcdefg | 23400s +-1 |
-		 | g    | a  | abcdefg | 23400s +-1 |
-    
-    @todo
-	Scenario: Bike - Ferry duration, individual parts
-		Given the node map
-		  | x | y |  | z |  |  | v |
-		  | a | b |  | c |  |  | d |
-
-		And the ways
-		 | nodes | highway | route | bicycle | duration |
-		 | xa    | primary |       |         |          |
-		 | yb    | primary |       |         |          |
-		 | zc    | primary |       |         |          |
-		 | vd    | primary |       |         |          |
-		 | abcd  |         | ferry | yes     | 1:00     |
-
-		When I route I should get
-		 | from | to | route | time      |
-		 | a    | d  | abcd  | 3600s +-1 |
-		 | a    | b  | abcd  | 600s +-1  |
-		 | b    | c  | abcd  | 1200s +-1 |
-		 | c    | d  | abcd  | 1800s +-1 |
+		 | from | to | route | time       |
+		 | a    | d  | abcd  | 3600s +-10 |
+		 | d    | a  | abcd  | 3600s +-10 |

features/bicycle/maxspeed.feature

@@ -3,20 +3,39 @@ Feature: Bike - Max speed restrictions
 
 	Background: Use specific speeds
 		Given the profile "bicycle"
-	
-	Scenario: Bike - Respect maxspeeds when lower that way type speed
-		Given the node map
-		 | a | b | c |
 
-		And the ways
-		 | nodes | highway     | maxspeed |
-		 | ab    | residential |          |
-		 | bc    | residential | 10       |
+	Scenario: Bicycle - Respect maxspeeds when lower that way type speed
+    	Then routability should be
+    	 | highway     | maxspeed | bothw    |
+    	 | residential |          | 49s ~10% |
+    	 | residential | 10       | 72s ~10% |
 
-		When I route I should get
-		 | from | to | route | time    |
-		 | a    | b  | ab    | 20s ~5% |
-		 | b    | c  | bc    | 36s ~5% |
+	Scenario: Bicycle - Ignore maxspeed when higher than way speed
+    	Then routability should be
+    	 | highway     | maxspeed | bothw    |
+    	 | residential |          | 49s ~10% |
+    	 | residential | 80       | 49s ~10% |
+    
+    @todo
+  	Scenario: Bicycle - Maxspeed formats
+ 		Then routability should be
+ 		 | highway     | maxspeed  | bothw     |
+ 		 | residential |           | 49s ~10%  |
+ 		 | residential | 5         | 144s ~10% |
+ 		 | residential | 5mph      | 90s ~10%  |
+ 		 | residential | 5 mph     | 90s ~10%  |
+ 		 | residential | 5MPH      | 90s ~10%  |
+ 		 | residential | 5 MPH     | 90s ~10%  |
+ 		 | trunk       | 5unknown  | 49s ~10%  |
+ 		 | trunk       | 5 unknown | 49s ~10%  |
+
+    @todo
+   	Scenario: Bicycle - Maxspeed special tags
+  		Then routability should be
+  		 | highway     | maxspeed | bothw    |
+  		 | residential |          | 49s ~10% |
+  		 | residential | none     | 49s ~10% |
+  		 | residential | signals  | 49s ~10% |
 
 	Scenario: Bike - Do not use maxspeed when higher that way type speed
 		Given the node map
@@ -29,5 +48,23 @@ Feature: Bike - Max speed restrictions
 
 		When I route I should get
 		 | from | to | route | time    |
-		 | a    | b  | ab    | 20s ~5% |
-		 | b    | c  | bc    | 20s ~5% |
+		 | a    | b  | ab    | 24s ~5% |
+		 | b    | c  | bc    | 24s ~5% |
+
+     Scenario: Bike - Forward/backward maxspeed
+        Given the shortcuts
+ 		 | key   | value    |
+ 		 | bike  | 49s ~10% |
+ 		 | run   | 73s ~10% |
+ 		 | walk  | 145s ~10% |
+ 		 | snail | 720s ~10% |
+
+  	 	Then routability should be
+     	 | maxspeed | maxspeed:forward | maxspeed:backward | forw  | backw |
+     	 |          |                  |                   | bike  | bike   |
+     	 | 10       |                  |                   | run   | run    |
+     	 |          | 10               |                   | run   | bike   |
+     	 |          |                  | 10                | bike  | run    |
+     	 | 1        | 10               |                   | run   | snail  |
+     	 | 1        |                  | 10                | snail | run    |
+     	 | 1        | 5                | 10                | walk  | run    |

features/bicycle/mode.feature

@@ -0,0 +1,89 @@
+@routing @bicycle @mode
+Feature: Bike - Mode flag
+
+	Background:
+		Given the profile "bicycle"
+    
+    @todo
+    Scenario: Bike - Mode when using a ferry
+    	Given the node map
+    	 | a | b |   |
+    	 |   | c | d |
+
+    	And the ways
+    	 | nodes | highway | route | duration |
+    	 | ab    | primary |       |          |
+    	 | bc    |         | ferry | 0:01     |
+    	 | cd    | primary |       |          |
+
+    	When I route I should get
+    	 | from | to | route    | turns                        | modes           |
+    	 | a    | d  | ab,bc,cd | head,right,left, destination | bike,ferry,bike |
+    	 | d    | a  | cd,bc,ab | head,right,left, destination | bike,ferry,bike |
+    	 | c    | a  | bc,ab    | head,left,destination        | ferry,bike      |
+    	 | d    | b  | cd,bc    | head,right,destination       | bike,ferry      |
+    	 | a    | c  | ab,bc    | head,right,destination       | bike,ferry      |
+    	 | b    | d  | bc,cd    | head,left,destination        | ferry,bike      |
+
+     @todo
+     Scenario: Bike - Mode when pushing bike against oneways
+     	Given the node map
+     	 | a | b |   |
+     	 |   | c | d |
+
+     	And the ways
+     	 | nodes | highway | oneway |
+     	 | ab    | primary |        |
+     	 | bc    | primary | yes    |
+     	 | cd    | primary |        |
+
+     	When I route I should get
+     	 | from | to | route    | turns                       | modes          |
+     	 | a    | d  | ab,bc,cd | head,right,left,destination | bike,push,bike |
+     	 | d    | a  | cd,bc,ab | head,right,left,destination | bike,push,bike |
+     	 | c    | a  | bc,ab    | head,left,destination       | push,bike      |
+     	 | d    | b  | cd,bc    | head,right,destination      | bike,push      |
+     	 | a    | c  | ab,bc    | head,right,destination      | bike,push      |
+     	 | b    | d  | bc,cd    | head,left,destination       | push,bike      |
+
+     @todo
+     Scenario: Bike - Mode when pushing on pedestrain streets
+     	Given the node map
+     	 | a | b |   |
+     	 |   | c | d |
+
+     	And the ways
+     	 | nodes | highway    |
+     	 | ab    | primary    |
+     	 | bc    | pedestrian |
+     	 | cd    | primary    |
+
+     	When I route I should get
+     	 | from | to | route    | turns                       | modes          |
+     	 | a    | d  | ab,bc,cd | head,right,left,destination | bike,push,bike |
+     	 | d    | a  | cd,bc,ab | head,right,left,destination | bike,push,bike |
+     	 | c    | a  | bc,ab    | head,left,destination       | push,bike      |
+     	 | d    | b  | cd,bc    | head,right,destination      | bike,push      |
+     	 | a    | c  | ab,bc    | head,right,destination      | bike,push      |
+     	 | b    | d  | bc,cd    | head,left,destination       | push,bike      |
+
+     @todo
+     Scenario: Bike - Mode when pushing on pedestrain areas
+     	Given the node map
+     	 | a | b |   |   |
+     	 |   | c | d | f |
+
+     	And the ways
+     	 | nodes | highway    | area |
+     	 | ab    | primary    |      |
+     	 | bcd   | pedestrian | yes  |
+     	 | df    | primary    |      |
+
+     	When I route I should get
+     	 | from | to | route     | modes          |
+     	 | a    | f  | ab,bcd,df | bike,push,bike |
+     	 | f    | a  | df,bcd,ab | bike,push,bike |
+     	 | d    | a  | bcd,ab    | push,bike      |
+     	 | f    | b  | df,bcd    | bike,push      |
+     	 | a    | d  | ab,bcd    | bike,push      |
+     	 | b    | f  | bcd,df    | push,bike      |

features/bicycle/names.feature

@@ -10,14 +10,15 @@ Feature: Bike - Street names in instructions
 		 |   | c |
 	
 		And the ways
-		 | nodes | name   |
-		 | ab    | My Way |
+		 | nodes | name     |
+		 | ab    | My Way   |
 		 | bc    | Your Way |
     
 		When I route I should get
 		 | from | to | route           |
 		 | a    | c  | My Way,Your Way |
-		
+	
+	@unnamed
 	Scenario: Bike - Use way type to describe unnamed ways
 		Given the node map
 		 | a | b | c | d |
@@ -25,8 +26,24 @@ Feature: Bike - Street names in instructions
 		And the ways
 		 | nodes | highway  | name |
 		 | ab    | cycleway |      |
-		 | bcd  | track    |      |
+		 | bcd   | track    |      |
 
 		When I route I should get
-		 | from | to | route          |
-		 | a    | d  | cycleway,track |
+		 | from | to | route                              |
+		 | a    | d  | {highway:cycleway},{highway:track} |
+
+  	@area @names @todo
+  	Scenario: Bike - name on streets overlapping an area
+  		Given the node map
+  		 | x | a | b | y |
+  		 |   | d | c |   |
+
+  		And the ways
+  		 | nodes | highway     | area |
+  		 | xaby  | residential |      |
+  		 | abcda | residential | yes  |
+
+  		When I route I should get
+  		 | from | to | route |
+  		 | x    | y  | xaby  |
+  		 | y    | x  | xaby  |

features/bicycle/oneway.feature

@@ -1,19 +1,20 @@
 @routing @bicycle @oneway
 Feature: Bike - Oneway streets
 Handle oneways streets, as defined at http://wiki.openstreetmap.org/wiki/OSM_tags_for_routing
+Usually we can push bikes against oneways, but we use foot=no to prevent this in these tests
 
 	Background:
 		Given the profile "bicycle"
 	
 	Scenario: Bike - Simple oneway
 		Then routability should be
-		 | highway | oneway | forw | backw |
-		 | primary | yes    | x    |       |
+		 | highway | foot | oneway | forw | backw |
+		 | primary | no   | yes    | x    |       |
 
 	Scenario: Simple reverse oneway
 		Then routability should be
-		 | highway | oneway | forw | backw |
-		 | primary | -1     |      | x     |
+		 | highway | foot | oneway | forw | backw |
+		 | primary | no   | -1     |      | x     |
 
 	Scenario: Bike - Around the Block
 		Given the node map
@@ -21,11 +22,11 @@ Handle oneways streets, as defined at http://wiki.openstreetmap.org/wiki/OSM_tag
 		 | d | c |
 	
 		And the ways
-		 | nodes | oneway |
-		 | ab    | yes    |
-		 | bc    |        |
-		 | cd    |        |
-		 | da    |        |
+		 | nodes | oneway | foot |
+		 | ab    | yes    | no   |
+		 | bc    |        | no   |
+		 | cd    |        | no   |
+		 | da    |        | no   |
     
 		When I route I should get
 		 | from | to | route    |
@@ -34,80 +35,94 @@ Handle oneways streets, as defined at http://wiki.openstreetmap.org/wiki/OSM_tag
 	
 	Scenario: Bike - Handle various oneway tag values
 	 	Then routability should be
-		 | oneway   | forw | backw |
-		 |          | x    | x     |
-		 | nonsense | x    | x     |
-		 | no       | x    | x     |
-		 | false    | x    | x     |
-		 | 0        | x    | x     |
-		 | yes      | x    |       |
-		 | true     | x    |       |
-		 | 1        | x    |       |
-		 | -1       |      | x     |
+		 | foot | oneway   | forw | backw |
+		 | no   |          | x    | x     |
+		 | no   | nonsense | x    | x     |
+		 | no   | no       | x    | x     |
+		 | no   | false    | x    | x     |
+		 | no   | 0        | x    | x     |
+		 | no   | yes      | x    |       |
+		 | no   | true     | x    |       |
+		 | no   | 1        | x    |       |
+		 | no   | -1       |      | x     |
 	
 	Scenario: Bike - Implied oneways
 	 	Then routability should be
-		 | highway       | bicycle | junction   | forw | backw |
-		 |               |         |            | x    | x     |
-		 |               |         | roundabout | x    |       |
-		 | motorway      | yes     |            | x    |       |
-		 | motorway_link | yes     |            | x    |       |
-		 | motorway      | yes     | roundabout | x    |       |
-		 | motorway_link | yes     | roundabout | x    |       |
+		 | highway       | foot | bicycle | junction   | forw | backw |
+		 |               | no   |         |            | x    | x     |
+		 |               | no   |         | roundabout | x    |       |
+		 | motorway      | no   | yes     |            | x    |       |
+		 | motorway_link | no   | yes     |            | x    |       |
+		 | motorway      | no   | yes     | roundabout | x    |       |
+		 | motorway_link | no   | yes     | roundabout | x    |       |
 
 	Scenario: Bike - Overriding implied oneways
 	 	Then routability should be
-		 | highway       | junction   | oneway | forw | backw |
-		 | primary       | roundabout | no     | x    | x     |
-		 | primary       | roundabout | yes    | x    |       |
-		 | motorway_link |            | -1     |      |       |
-		 | trunk_link    |            | -1     |      |       |
-		 | primary       | roundabout | -1     |      | x     |
+		 | highway       | foot | junction   | oneway | forw | backw |
+		 | primary       | no   | roundabout | no     | x    | x     |
+		 | primary       | no   | roundabout | yes    | x    |       |
+		 | motorway_link | no   |            | -1     |      |       |
+		 | trunk_link    | no   |            | -1     |      |       |
+		 | primary       | no   | roundabout | -1     |      | x     |
 	
 	Scenario: Bike - Oneway:bicycle should override normal oneways tags
 	 	Then routability should be
-		 | oneway:bicycle | oneway | junction   | forw | backw |
-		 | yes            |        |            | x    |       |
-		 | yes            | yes    |            | x    |       |
-		 | yes            | no     |            | x    |       |
-		 | yes            | -1     |            | x    |       |
-		 | yes            |        | roundabout | x    |       |
-		 | no             |        |            | x    | x     |
-		 | no             | yes    |            | x    | x     |
-		 | no             | no     |            | x    | x     |
-		 | no             | -1     |            | x    | x     |
-		 | no             |        | roundabout | x    | x     |
-		 | -1             |        |            |      | x     |
-		 | -1             | yes    |            |      | x     |
-		 | -1             | no     |            |      | x     |
-		 | -1             | -1     |            |      | x     |
-		 | -1             |        | roundabout |      | x     |
+		 | foot | oneway:bicycle | oneway | junction   | forw | backw |
+		 | no   | yes            |        |            | x    |       |
+		 | no   | yes            | yes    |            | x    |       |
+		 | no   | yes            | no     |            | x    |       |
+		 | no   | yes            | -1     |            | x    |       |
+		 | no   | yes            |        | roundabout | x    |       |
+		 | no   | no             |        |            | x    | x     |
+		 | no   | no             | yes    |            | x    | x     |
+		 | no   | no             | no     |            | x    | x     |
+		 | no   | no             | -1     |            | x    | x     |
+		 | no   | no             |        | roundabout | x    | x     |
+		 | no   | -1             |        |            |      | x     |
+		 | no   | -1             | yes    |            |      | x     |
+		 | no   | -1             | no     |            |      | x     |
+		 | no   | -1             | -1     |            |      | x     |
+		 | no   | -1             |        | roundabout |      | x     |
 	
 	Scenario: Bike - Contra flow
 	 	Then routability should be
-		 | oneway | cycleway       | forw | backw |
-		 | yes    | opposite       | x    | x     |
-		 | yes    | opposite_track | x    | x     |
-		 | yes    | opposite_lane  | x    | x     |
-		 | -1     | opposite       | x    | x     |
-		 | -1     | opposite_track | x    | x     |
-		 | -1     | opposite_lane  | x    | x     |
-		 | no     | opposite       | x    | x     |
-		 | no     | opposite_track | x    | x     |
-		 | no     | opposite_lane  | x    | x     |
+		 | foot | oneway | cycleway       | forw | backw |
+		 | no   | yes    | opposite       | x    | x     |
+		 | no   | yes    | opposite_track | x    | x     |
+		 | no   | yes    | opposite_lane  | x    | x     |
+		 | no   | -1     | opposite       | x    | x     |
+		 | no   | -1     | opposite_track | x    | x     |
+		 | no   | -1     | opposite_lane  | x    | x     |
+		 | no   | no     | opposite       | x    | x     |
+		 | no   | no     | opposite_track | x    | x     |
+		 | no   | no     | opposite_lane  | x    | x     |
 
 	Scenario: Bike - Should not be affected by car tags
 		Then routability should be
-		 | junction   | oneway | oneway:car | forw | backw |
-		 |            | yes    | yes        | x    |       |
-		 |            | yes    | no         | x    |       |
-		 |            | yes    | -1         | x    |       |
-		 |            | no     | yes        | x    | x     |
-		 |            | no     | no         | x    | x     |
-		 |            | no     | -1         | x    | x     |
-		 |            | -1     | yes        |      | x     |
-		 |            | -1     | no         |      | x     |
-		 |            | -1     | -1         |      | x     |
-		 | roundabout |        | yes        | x    |       |
-		 | roundabout |        | no         | x    |       |
-		 | roundabout |        | -1         | x    |       |
+		 | foot | junction   | oneway | oneway:car | forw | backw |
+		 | no   |            | yes    | yes        | x    |       |
+		 | no   |            | yes    | no         | x    |       |
+		 | no   |            | yes    | -1         | x    |       |
+		 | no   |            | no     | yes        | x    | x     |
+		 | no   |            | no     | no         | x    | x     |
+		 | no   |            | no     | -1         | x    | x     |
+		 | no   |            | -1     | yes        |      | x     |
+		 | no   |            | -1     | no         |      | x     |
+		 | no   |            | -1     | -1         |      | x     |
+		 | no   | roundabout |        | yes        | x    |       |
+		 | no   | roundabout |        | no         | x    |       |
+		 | no   | roundabout |        | -1         | x    |       |
+
+   	Scenario: Bike - Two consecutive oneways
+   		Given the node map
+   		 | a | b | c |
+
+   		And the ways
+   		 | nodes | oneway |
+   		 | ab    | yes    |
+   		 | bc    | yes    |
+
+
+   		When I route I should get
+   		 | from | to | route |
+   		 | a    | c  | ab,bc |

features/bicycle/pushing.feature

@@ -0,0 +1,124 @@
+@routing @bicycle @pushing
+Feature: Bike - Accessability of different way types
+
+	Background:
+		Given the profile "bicycle"
+        Given the shortcuts
+		 | key  | value     |
+		 | bike | 49s ~20%  |
+		 | foot | 121s ~20% |
+
+	Scenario: Bike - Pushing bikes on pedestrian-only ways
+	 	Then routability should be
+		 | highway    | oneway | forw | backw |
+		 | (nil)      |        |      |       |
+		 | cycleway   |        | bike | bike  |
+		 | primary    |        | bike | bike  |
+		 | pedestrian |        | foot | foot  |
+		 | footway    |        | foot | foot  |
+		 | primary    | yes    | bike | foot  |
+
+ 	Scenario: Bike - Pushing bikes against normal oneways
+ 	 	Then routability should be
+ 		 | highway    | oneway | forw | backw |
+ 		 | (nil)      |        |      |       |
+ 		 | primary    | yes    | bike | foot  |
+ 		 | pedestrian | yes    | foot | foot  |
+
+  	Scenario: Bike - Pushing bikes against reverse oneways
+  	 	Then routability should be
+  		 | highway    | oneway | forw | backw |
+  		 | (nil)      |        |      |       |
+  		 | primary    | -1     | foot | bike  |
+  		 | pedestrian | -1     | foot | foot  |
+
+ 	@square	
+ 	Scenario: Bike - Push bikes on pedestrian areas
+ 		Given the node map
+ 		 | x |   |
+ 		 | a | b |
+ 		 | d | c |
+
+ 		And the ways
+ 		 | nodes | area | highway    |
+ 		 | xa    |      | primary    |
+ 		 | abcda | yes  | pedestrian |
+
+ 		When I route I should get
+ 		 | from | to | route |
+ 		 | a    | b  | abcda |
+ 		 | a    | d  | abcda |
+ 		 | b    | c  | abcda |
+ 		 | c    | b  | abcda |
+ 		 | c    | d  | abcda |
+ 		 | d    | c  | abcda |
+ 		 | d    | a  | abcda |
+ 		 | a    | d  | abcda |
+
+ 	Scenario: Bike - Pushing bikes on ways with foot=yes
+ 	 	Then routability should be
+ 		 | highway  | foot | bothw |
+ 		 | motorway |      |       |
+ 		 | motorway | yes  | foot  |
+ 		 | runway   |      |       |
+ 		 | runway   | yes  | foot  |
+    
+    @todo
+  	Scenario: Bike - Pushing bikes on ways with foot=yes in one direction
+  	 	Then routability should be
+  		 | highway  | foot:forward | foot:backward | forw | backw |
+  		 | motorway |              |               |      |       |
+  		 | motorway | yes          |               | foot |       |
+  		 | motorway |              | yes           |      | foot  |
+
+    @construction
+ 	Scenario: Bike - Don't allow routing on ways still under construction 
+ 	 	Then routability should be
+ 		 | highway      | foot | bicycle | bothw |
+ 		 | primary      |      |         | x     |
+ 		 | construction |      |         |       |
+ 		 | construction | yes  |         |       |
+ 		 | construction |      | yes     |       |
+        
+    @roundabout
+  	Scenario: Bike - Don't push bikes against oneway flow on roundabouts
+  	 	Then routability should be
+  		 | junction   | forw | backw |
+  		 | roundabout | x    |       |
+ 
+  	Scenario: Bike - Instructions when pushing bike on oneways
+  		Given the node map
+  		 | a | b |   |
+  		 |   | c | d |
+
+  		And the ways
+  		 | nodes | highway | oneway |
+  		 | ab    | primary |        |
+  		 | bc    | primary | yes    |
+  		 | cd    | primary |        |
+
+  		When I route I should get
+  		 | from | to | route    | turns                                              |
+  		 | a    | d  | ab,bc,cd | head,right,left,destination                        |
+  		 | d    | a  | cd,bc,ab | head,enter_contraflow,leave_contraflow,destination |
+  		 | c    | a  | bc,ab    | head,leave_contraflow,destination                  |
+  		 | d    | b  | cd,bc    | head,enter_contraflow,destination                  |
+
+  	@todo
+    Scenario: Bike - Instructions when pushing bike on footway/pedestrian, etc.
+   		Given the node map
+   		 | a | b |   |
+   		 |   | c | d |
+
+   		And the ways
+   		 | nodes | highway |
+   		 | ab    | primary |
+   		 | bc    | footway |
+   		 | cd    | primary |
+
+   		When I route I should get
+   		 | from | to | route    | turns                                              |
+   		 | a    | d  | ab,bc,cd | head,right,left,destination                        |
+   		 | d    | a  | cd,bc,ab | head,enter_contraflow,leave_contraflow,destination |
+   		 | c    | a  | bc,ab    | head,leave_contraflow,destination                  |
+   		 | d    | b  | cd,bc    | head,enter_contraflow,destination                  |

features/bicycle/ref.feature

@@ -0,0 +1,41 @@
+@routing @bicycle @ref @name
+Feature: Bike - Way ref
+
+	Background:
+		Given the profile "bicycle"
+	
+	Scenario: Bike - Way with both name and ref
+		Given the node map
+		 | a | b |
+	
+		And the ways
+		 | nodes | name         | ref |
+		 | ab    | Utopia Drive | E7  |
+    
+		When I route I should get
+		 | from | to | route             |
+		 | a    | b  | Utopia Drive / E7 |
+
+ 	Scenario: Bike - Way with only ref
+ 		Given the node map
+ 		 | a | b |
+
+ 		And the ways
+ 		 | nodes | name | ref |
+ 		 | ab    |      | E7  |
+
+ 		When I route I should get
+ 		 | from | to | route |
+ 		 | a    | b  | E7    |
+
+  	Scenario: Bike - Way with only name
+  		Given the node map
+  		 | a | b |
+
+  		And the ways
+  		 | nodes | name         |
+  		 | ab    | Utopia Drive |
+
+  		When I route I should get
+  		 | from | to | route        |
+  		 | a    | b  | Utopia Drive |

features/bicycle/restrictions.feature

@@ -1,9 +1,9 @@
 @routing @bicycle @restrictions
 Feature: Bike - Turn restrictions
-	Handle turn restrictions as defined by http://wiki.openstreetmap.org/wiki/Relation:restriction
+	Ignore turn restrictions on bicycle, since you always become a temporary pedestrian.
 	Note that if u-turns are allowed, turn restrictions can lead to suprising, but correct, routes.
 	
-	Background: Use car routing
+	Background:
 		Given the profile "bicycle"
 	
 	@no_turning
@@ -14,11 +14,11 @@ Feature: Bike - Turn restrictions
 		 |   | s |   |
 
 		And the ways
-		 | nodes | oneway |
-		 | sj    | yes    |
-		 | nj    | -1     |
-		 | wj    | -1     |
-		 | ej    | -1     |
+		 | nodes | oneway | foot |
+		 | sj    | yes    | no   |
+		 | nj    | -1     | no   |
+		 | wj    | -1     | no   |
+		 | ej    | -1     | no   |
 
 		And the relations
 		 | type        | way:from | way:to | node:via | restriction  |
@@ -26,7 +26,7 @@ Feature: Bike - Turn restrictions
 
 		When I route I should get
 		 | from | to | route |
-		 | s    | w  |       |
+		 | s    | w  | sj,wj |
 		 | s    | n  | sj,nj |
 		 | s    | e  | sj,ej |
 
@@ -38,11 +38,11 @@ Feature: Bike - Turn restrictions
 		 |   | s |   |
 
 		And the ways
-		 | nodes | oneway |
-		 | sj    | yes    |
-		 | nj    | -1     |
-		 | wj    | -1     |
-		 | ej    | -1     |
+		 | nodes | oneway | foot |
+		 | sj    | yes    | no   |
+		 | nj    | -1     | no   |
+		 | wj    | -1     | no   |
+		 | ej    | -1     | no   |
 
 		And the relations
 		 | type        | way:from | way:to | node:via | restriction   |
@@ -52,7 +52,7 @@ Feature: Bike - Turn restrictions
 		 | from | to | route |
 		 | s    | w  | sj,wj |
 		 | s    | n  | sj,nj |
-		 | s    | e  |       |
+		 | s    | e  | sj,ej |
 
 	@no_turning
 	Scenario: Bike - No u-turn
@@ -62,11 +62,11 @@ Feature: Bike - Turn restrictions
 		 |   | s |   |
 
 		And the ways
-		 | nodes | oneway |
-		 | sj    | yes    |
-		 | nj    | -1     |
-		 | wj    | -1     |
-		 | ej    | -1     |
+		 | nodes | oneway | foot |
+		 | sj    | yes    | no   |
+		 | nj    | -1     | no   |
+		 | wj    | -1     | no   |
+		 | ej    | -1     | no   |
 
 		And the relations
 		 | type        | way:from | way:to | node:via | restriction |
@@ -74,7 +74,7 @@ Feature: Bike - Turn restrictions
 
 		When I route I should get
 		 | from | to | route |
-		 | s    | w  |       |
+		 | s    | w  | sj,wj |
 		 | s    | n  | sj,nj |
 		 | s    | e  | sj,ej |
 
@@ -86,11 +86,11 @@ Feature: Bike - Turn restrictions
 		 |   | s |   |
 
 		And the ways
-		 | nodes | oneway |
-		 | sj    | yes    |
-		 | nj    | -1     |
-		 | wj    | -1     |
-		 | ej    | -1     |
+		 | nodes | oneway | foot |
+		 | sj    | yes    | no   |
+		 | nj    | -1     | no   |
+		 | wj    | -1     | no   |
+		 | ej    | -1     | no   |
 
 		And the relations
 		 | type        | way:from | way:to | node:via | restriction      |
@@ -98,7 +98,7 @@ Feature: Bike - Turn restrictions
 
 		When I route I should get
 		 | from | to | route |
-		 | s    | w  |       |
+		 | s    | w  | sj,wj |
 		 | s    | n  | sj,nj |
 		 | s    | e  | sj,ej |
 
@@ -110,11 +110,11 @@ Feature: Bike - Turn restrictions
 		 |   | s |   |
 
 		And the ways
-		 | nodes | oneway |
-		 | sj    | yes    |
-		 | nj    | -1     |
-		 | wj    | -1     |
-		 | ej    | -1     |
+		 | nodes | oneway | foot |
+		 | sj    | yes    | no   |
+		 | nj    | -1     | no   |
+		 | wj    | -1     | no   |
+		 | ej    | -1     | no   |
 
 		And the relations
 		 | type        | way:from | way:to | node:via | restriction    |
@@ -123,8 +123,8 @@ Feature: Bike - Turn restrictions
 		When I route I should get
 		 | from | to | route |
 		 | s    | w  | sj,wj |
-		 | s    | n  |       |
-		 | s    | e  |       |
+		 | s    | n  | sj,nj |
+		 | s    | e  | sj,ej |
 
 	@only_turning
 	Scenario: Bike - Only right turn
@@ -134,11 +134,11 @@ Feature: Bike - Turn restrictions
 		 |   | s |   |
 
 		And the ways
-		 | nodes | oneway |
-		 | sj    | yes    |
-		 | nj    | -1     |
-		 | wj    | -1     |
-		 | ej    | -1     |
+		 | nodes | oneway | foot |
+		 | sj    | yes    | no   |
+		 | nj    | -1     | no   |
+		 | wj    | -1     | no   |
+		 | ej    | -1     | no   |
 
 		And the relations
 		 | type        | way:from | way:to | node:via | restriction     |
@@ -146,8 +146,8 @@ Feature: Bike - Turn restrictions
 
 		When I route I should get
 		 | from | to | route |
-		 | s    | w  |       |
-		 | s    | n  |       |
+		 | s    | w  | sj,wj |
+		 | s    | n  | sj,nj |
 		 | s    | e  | sj,ej |
 	
 	@only_turning
@@ -158,11 +158,11 @@ Feature: Bike - Turn restrictions
 		 |   | s |   |
 
 		And the ways
-		 | nodes | oneway |
-		 | sj    | yes    |
-		 | nj    | -1     |
-		 | wj    | -1     |
-		 | ej    | -1     |
+		 | nodes | oneway | foot |
+		 | sj    | yes    | no   |
+		 | nj    | -1     | no   |
+		 | wj    | -1     | no   |
+		 | ej    | -1     | no   |
 
 		And the relations
 		 | type        | way:from | way:to | node:via | restriction      |
@@ -170,9 +170,9 @@ Feature: Bike - Turn restrictions
 
 		When I route I should get
 		 | from | to | route |
-		 | s    | w  |       |
+		 | s    | w  | sj,wj |
 		 | s    | n  | sj,nj |
-		 | s    | e  |       |
+		 | s    | e  | sj,ej |
 
 	@no_turning
 	Scenario: Bike - Handle any only_* restriction
@@ -182,11 +182,11 @@ Feature: Bike - Turn restrictions
 		 |   | s |   |
 
 		And the ways
-		 | nodes | oneway |
-		 | sj    | yes    |
-		 | nj    | -1     |
-		 | wj    | -1     |
-		 | ej    | -1     |
+		 | nodes | oneway | foot |
+		 | sj    | yes    | no   |
+		 | nj    | -1     | no   |
+		 | wj    | -1     | no   |
+		 | ej    | -1     | no   |
 
 		And the relations
 		 | type        | way:from | way:to | node:via | restriction        |
@@ -194,11 +194,11 @@ Feature: Bike - Turn restrictions
 
 		When I route I should get
 		 | from | to | route |
-		 | s    | w  |       |
+		 | s    | w  | sj,wj |
 		 | s    | n  | sj,nj |
-		 | s    | e  |       |
+		 | s    | e  | sj,ej |
 
- 	@except @todo
+ 	@except
  	Scenario: Bike - Except tag and on no_ restrictions
  		Given the node map
  		 | b | x | c |
@@ -206,29 +206,29 @@ Feature: Bike - Turn restrictions
  		 |   | s |   |
 
  		And the ways
- 		 | nodes | oneway |
- 		 | sj    | yes    |
- 		 | xj    | -1     |
- 		 | aj    | -1     |
- 		 | bj    | -1     |
- 		 | cj    | -1     |
- 		 | dj    | -1     |
+ 		 | nodes | oneway | foot |
+ 		 | sj    | no     | no   |
+ 		 | xj    | -1     | no   |
+ 		 | aj    | -1     | no   |
+ 		 | bj    | no     | no   |
+ 		 | cj    | -1     | no   |
+ 		 | dj    | -1     | no   |
 
  		And the relations
  		 | type        | way:from | way:to | node:via | restriction   | except  |
  		 | restriction | sj       | aj     | j        | no_left_turn  | bicycle |
  		 | restriction | sj       | bj     | j        | no_left_turn  |         |
- 		 | restriction | sj       | cj     | j        | no_right_turn | bicycle |
- 		 | restriction | sj       | dj     | j        | no_right_turn |         |
+ 		 | restriction | sj       | cj     | j        | no_right_turn |         |
+ 		 | restriction | sj       | dj     | j        | no_right_turn | bicycle |
 
  		When I route I should get
  		 | from | to | route |
  		 | s    | a  | sj,aj |
- 		 | s    | b  |       |
- 		 | s    | c  |       |
+ 		 | s    | b  | sj,bj |
+ 		 | s    | c  | sj,cj |
  		 | s    | d  | sj,dj |
 
-  	@except @todo
+  	@except
   	Scenario: Bike - Except tag and on only_ restrictions
   		Given the node map
   		 | a |   | b |
@@ -236,10 +236,10 @@ Feature: Bike - Turn restrictions
   		 |   | s |   |
 
   		And the ways
-  		 | nodes | oneway |
-  		 | sj    | yes    |
-  		 | aj    | -1     |
-  		 | bj    | -1     |
+  		 | nodes | oneway | foot |
+  		 | sj    | yes    | no   |
+  		 | aj    | no     | no   |
+  		 | bj    | no     | no   |
 
   		And the relations
   		 | type        | way:from | way:to | node:via | restriction      | except  |
@@ -249,3 +249,41 @@ Feature: Bike - Turn restrictions
   		 | from | to | route |
   		 | s    | a  | sj,aj |
   		 | s    | b  | sj,bj |
+
+  	@except
+  	Scenario: Bike - Multiple except tag values
+  		Given the node map
+  		 | s | j | a |
+  		 |   |   | b |
+  		 |   |   | c |
+  		 |   |   | d |
+  		 |   |   | e |
+  		 |   |   | f |
+
+  		And the ways
+  		 | nodes | oneway | foot |
+  		 | sj    | yes    | no   |
+  		 | ja    | yes    | no   |
+  		 | jb    | yes    | no   |
+  		 | jc    | yes    | no   |
+  		 | jd    | yes    | no   |
+  		 | je    | yes    | no   |
+  		 | jf    | yes    | no   |
+
+  		And the relations
+  		 | type        | way:from | way:to | node:via | restriction    | except           |
+  		 | restriction | sj       | ja     | j        | no_straight_on |                  |
+  		 | restriction | sj       | jb     | j        | no_straight_on | bicycle          |
+  		 | restriction | sj       | jc     | j        | no_straight_on | bus; bicycle     |
+  		 | restriction | sj       | jd     | j        | no_straight_on | bicycle; motocar |
+  		 | restriction | sj       | je     | j        | no_straight_on | bus, bicycle     |
+  		 | restriction | sj       | jf     | j        | no_straight_on | bicycle, bus     |
+
+  		When I route I should get
+  		 | from | to | route |
+  		 | s    | a  | sj,ja |
+  		 | s    | b  | sj,jb |
+  		 | s    | c  | sj,jc |
+  		 | s    | d  | sj,jd |
+  		 | s    | e  | sj,je |
+  		 | s    | f  | sj,jf |

features/bicycle/train.feature

@@ -30,3 +30,10 @@ Bringing bikes on trains and subways
 		 | (nil)   | some_tag   |         |       |
 		 | (nil)   | some_tag   | no      |       |
 		 | (nil)   | some_tag   | yes     | x     |
+
+	@construction
+ 	Scenario: Bike - Don't route on railways under construction
+ 	 	Then routability should be
+ 		 | highway | railway      | bicycle | bothw |
+ 		 | primary |              |         | x     |
+ 		 | (nil)   | construction | yes     |       |

features/bicycle/turn_penalty.feature

@@ -0,0 +1,33 @@
+@routing @bicycle @turn_penalty
+Feature: Turn Penalties
+
+    Background:
+        Given the profile "turnbot"     
+
+    Scenario: Bike - turns should incur a delay that depend on the angle
+
+        Given the node map
+         | c | d | e |
+         | b | j | f |
+         | a | s | g |
+
+        And the ways
+         | nodes |
+         | sj    |
+         | ja    |
+         | jb    |
+         | jc    |
+         | jd    |
+         | je    |
+         | jf    |
+         | jg    |
+
+        When I route I should get
+         | from | to | route | time    | distance |
+         | s    | a  | sj,ja | 39s +-1 | 242m +-1 |
+         | s    | b  | sj,jb | 30s +-1 | 200m +-1 |
+         | s    | c  | sj,jc | 29s +-1 | 242m +-1 |
+         | s    | d  | sj,jd | 20s +-1 | 200m +-1 |
+         | s    | e  | sj,je | 29s +-1 | 242m +-1 |
+         | s    | f  | sj,jf | 30s +-1 | 200m +-1 |
+         | s    | g  | sj,jg | 39s +-1 | 242m +-1 |

features/bicycle/way.feature

@@ -4,32 +4,38 @@ Feature: Bike - Accessability of different way types
 	Background:
 		Given the profile "bicycle"
 
-	Scenario: Bike - Basic access
+	Scenario: Bike - Routability of way types
 	Bikes are allowed on footways etc because you can pull your bike at a lower speed.
-	 	Given the profile "bicycle"
+	Pier is not allowed, since it's tagged using man_made=pier.
 	 	Then routability should be
-		 | highway        | forw |
-		 | (nil)          |      |
-		 | motorway       |      |
-		 | motorway_link  |      |
-		 | trunk          |      |
-		 | trunk_link     |      |
-		 | primary        | x    |
-		 | primary_link   | x    |
-		 | secondary      | x    |
-		 | secondary_link | x    |
-		 | tertiary       | x    |
-		 | tertiary_link  | x    |
-		 | residential    | x    |
-		 | service        | x    |
-		 | unclassified   | x    |
-		 | living_street  | x    |
-		 | road           | x    |
-		 | track          | x    |
-		 | path           | x    |
-		 | footway        | x    |
-		 | pedestrian     | x    |
-		 | steps          | x    |
-		 | pier           | x    |
-		 | cycleway       | x    |
-		 | bridleway      |      |
+		 | highway        | bothw |
+		 | (nil)          |       |
+		 | motorway       |       |
+		 | motorway_link  |       |
+		 | trunk          |       |
+		 | trunk_link     |       |
+		 | primary        | x     |
+		 | primary_link   | x     |
+		 | secondary      | x     |
+		 | secondary_link | x     |
+		 | tertiary       | x     |
+		 | tertiary_link  | x     |
+		 | residential    | x     |
+		 | service        | x     |
+		 | unclassified   | x     |
+		 | living_street  | x     |
+		 | road           | x     |
+		 | track          | x     |
+		 | path           | x     |
+		 | footway        | x     |
+		 | pedestrian     | x     |
+		 | steps          | x     |
+		 | cycleway       | x     |
+		 | bridleway      |       |
+		 | pier           |       |
+
+ 	Scenario: Bike - Routability of man_made structures
+ 	 	Then routability should be
+ 		 | highway | man_made | bothw |
+ 		 | (nil)   | (nil)    |       |
+ 		 | (nil)   | pier     | x     |

features/car/maxspeed.feature

@@ -10,16 +10,16 @@ Feature: Car - Max speed restrictions
 		 | a | b | c |
 
 		And the ways
-		 | nodes | highway  | maxspeed |
-		 | ab    | trunk |          |
-		 | bc    | trunk | 10       |
+		 | nodes | highway | maxspeed |
+		 | ab    | trunk   |          |
+		 | bc    | trunk   | 10       |
 
 		When I route I should get
 		 | from | to | route | time      |
 		 | a    | b  | ab    | 42s ~10%  |
 		 | b    | c  | bc    | 360s ~10% |
 
-	Scenario: Car - Ignore maxspeed when higher than way speed
+	Scenario: Car - Do not ignore maxspeed when higher than way speed
 		Given the node map
 		 | a | b | c |
 
@@ -31,4 +31,24 @@ Feature: Car - Max speed restrictions
 		When I route I should get
 		 | from | to | route | time      |
 		 | a    | b  | ab    | 144s ~10% |
-		 | b    | c  | bc    | 144s ~10%  |
+		 | b    | c  | bc    | 42s ~10%  |
+
+     Scenario: Car - Forward/backward maxspeed
+        Given the shortcuts
+ 		 | key   | value     |
+ 		 | car   | 12s ~10%  |
+ 		 | run   | 73s ~10%  |
+ 		 | walk  | 146s ~10% |
+ 		 | snail | 720s ~10% |
+  		
+  		And a grid size of 100 meters
+
+  	 	Then routability should be
+     	 | maxspeed | maxspeed:forward | maxspeed:backward | forw  | backw |
+     	 |          |                  |                   | car   | car   |
+     	 | 10       |                  |                   | run   | run   |
+     	 |          | 10               |                   | run   | car   |
+     	 |          |                  | 10                | car   | run   |
+     	 | 1        | 10               |                   | run   | snail |
+     	 | 1        |                  | 10                | snail | run   |
+     	 | 1        | 5                | 10                | walk  | run   |

features/car/oneway.feature

@@ -56,4 +56,18 @@ Handle oneways streets, as defined at http://wiki.openstreetmap.org/wiki/OSM_tag
 		 | primary |            | -1     | -1             |      | x     |
 		 | primary | roundabout |        | yes            | x    |       |
 		 | primary | roundabout |        | no             | x    |       |
-		 | primary | roundabout |        | -1             | x    |       |
+		 | primary | roundabout |        | -1             | x    |       |
+
+  	Scenario: Car - Two consecutive oneways
+  		Given the node map
+  		 | a | b | c |
+
+  		And the ways
+  		 | nodes | oneway |
+  		 | ab    | yes    |
+  		 | bc    | yes    |
+
+
+  		When I route I should get
+  		 | from | to | route |
+  		 | a    | c  | ab,bc |

features/car/restrictions.feature

@@ -198,8 +198,8 @@ Feature: Car - Turn restrictions
 		 | s    | n  | sj,nj |
 		 | s    | e  |       |
 
-  	@except @todo
-  	Scenario: Bike - Except tag and on no_ restrictions
+  	@except
+  	Scenario: Car - Except tag and on no_ restrictions
   		Given the node map
   		 | b | x | c |
   		 | a | j | d |
@@ -207,19 +207,19 @@ Feature: Car - Turn restrictions
 
   		And the ways
   		 | nodes | oneway |
-  		 | sj    | yes    |
+  		 | sj    | no     |
   		 | xj    | -1     |
   		 | aj    | -1     |
-  		 | bj    | -1     |
-  		 | cj    | -1     |
+  		 | bj    | no     |
+  		 | cj    | no     |
   		 | dj    | -1     |
 
   		And the relations
   		 | type        | way:from | way:to | node:via | restriction   | except   |
   		 | restriction | sj       | aj     | j        | no_left_turn  | motorcar |
   		 | restriction | sj       | bj     | j        | no_left_turn  |          |
-  		 | restriction | sj       | cj     | j        | no_right_turn | motorcar |
-  		 | restriction | sj       | dj     | j        | no_right_turn |          |
+  		 | restriction | sj       | cj     | j        | no_right_turn |          |
+  		 | restriction | sj       | dj     | j        | no_right_turn | motorcar |
 
   		When I route I should get
   		 | from | to | route |
@@ -228,8 +228,8 @@ Feature: Car - Turn restrictions
   		 | s    | c  |       |
   		 | s    | d  | sj,dj |
 
-   	@except @todo
-   	Scenario: Bike - Except tag and on only_ restrictions
+   	@except
+   	Scenario: Car - Except tag and on only_ restrictions
    		Given the node map
    		 | a |   | b |
    		 |   | j |   |
@@ -238,8 +238,8 @@ Feature: Car - Turn restrictions
    		And the ways
    		 | nodes | oneway |
    		 | sj    | yes    |
-   		 | aj    | -1     |
-   		 | bj    | -1     |
+   		 | aj    | no     |
+   		 | bj    | no     |
 
    		And the relations
    		 | type        | way:from | way:to | node:via | restriction      | except   |

features/car/shuttle_train.feature

@@ -0,0 +1,33 @@
+@routing @car @shuttle_train
+Feature: Car - Handle ferryshuttle train routes
+
+	Background:
+		Given the profile "car"
+
+	Scenario: Car - Use a ferry route
+		Given the node map
+		 | a | b | c |   |   |   |
+		 |   |   | d |   |   |   |
+		 |   |   | e | f | g | h |
+
+		And the ways
+		 | nodes | highway | route         | bicycle |
+		 | abc   | primary |               |         |
+		 | cde   |         | shuttle_train | yes     |
+		 | ef    | primary |               |         |
+		 | fg    |         | ferry_man     |         |
+		 | gh	 | primary |               | no      |
+
+		When I route I should get
+		 | from | to | route      |
+		 | a    | f  | abc,cde,ef |
+		 | b    | f  | abc,cde,ef |
+		 | e    | c  | cde        |
+		 | e    | b  | cde,abc    |
+		 | e    | a  | cde,abc    |
+		 | c    | e  | cde        |
+		 | c    | f  | cde,ef     |
+		 | f    | g  |            |
+		 | g    | h  | gh		  |
+
+

features/foot/maxspeed.feature

@@ -0,0 +1,20 @@
+@routing @maxspeed @foot
+Feature: Foot - Ignore max speed restrictions
+
+Background: Use specific speeds
+	Given the profile "foot"
+
+@todo
+Scenario: Foot - Ignore maxspeed
+	Then routability should be
+	 | highway     | maxspeed  | bothw     |
+	 | residential |           | 145s ~10% |
+	 | residential | 1         | 145s ~10% |
+	 | residential | 100       | 145s ~10% |
+	 | residential | 1         | 145s ~10% |
+	 | residential | 1mph      | 145s ~10% |
+	 | residential | 1 mph     | 145s ~10% |
+	 | residential | 1unknown  | 145s ~10% |
+	 | residential | 1 unknown | 145s ~10% |
+	 | residential | none      | 145s ~10% |
+	 | residential | signals   | 145s ~10% |

features/nearest/pick.feature

@@ -0,0 +1,56 @@
+@nearest
+Feature: Locating Nearest node on a Way - pick closest way
+
+	Background:
+		Given the profile "testbot"
+	
+	Scenario: Nearest - two ways crossing
+		Given the node map
+		 |   | 0 | c | 1 |   |
+		 | 7 |   | n |   | 2 |
+		 | a | k | x | m | b |
+		 | 6 |   | l |   | 3 |
+		 |   | 5 | d | 4 |   |
+
+		And the ways
+		 | nodes |
+		 | axb   |
+		 | cxd   |
+
+		When I request nearest I should get
+		 | in | out |
+		 | 0  | c   |
+		 | 1  | c   |
+		 | 2  | b   |
+		 | 3  | b   |
+		 | 4  | d   |
+		 | 5  | d   |
+		 | 6  | a   |
+		 | 7  | a   |
+		 | k  | k   |
+		 | l  | l   |
+		 | m  | m   |
+		 | n  | n   |
+
+ 	Scenario: Nearest - inside a triangle
+ 		Given the node map
+		 |   |  |  |   |   | c |   |   |  |  |   |
+		 |   |  |  |   |   |   |   |   |  |  |   |
+		 |   |  |  | y |   |   |   | z |  |  |   |
+		 |   |  |  |   | 0 |   | 1 |   |  |  |   |
+		 |   |  |  | 2 |   | 3 |   | 4 |  |  |   |
+		 | a |  |  | x |   | u |   | w |  |  | b |
+
+ 		And the ways
+ 		 | nodes |
+ 		 | ab    |
+ 		 | bc    |
+ 		 | ca    |
+
+ 		When I request nearest I should get
+ 		 | in | out |
+ 		 | 0  | y   |
+ 		 | 1  | z   |
+ 		 | 2  | x   |
+ 		 | 3  | u   |
+ 		 | 4  | w   |

features/nearest/projection.feature

@@ -0,0 +1,105 @@
+@nearest
+Feature: Locating Nearest node on a Way - basic projection onto way
+
+	Background:
+		Given the profile "testbot"
+	
+	Scenario: Nearest - easy-west way
+		Given the node map
+		 | 0 | 1 | 2 | 3 | 4 |
+		 |   | a | x | b |   |
+		 | 5 | 6 | 7 | 8 | 9 |
+
+		And the ways
+		 | nodes |
+		 | ab    |
+
+		When I request nearest I should get
+		 | in | out |
+		 | 0  | a   |
+		 | 1  | a   |
+		 | 2  | x   |
+		 | 3  | b   |
+		 | 4  | b   |
+		 | 5  | a   |
+		 | 6  | a   |
+		 | 7  | x   |
+		 | 8  | b   |
+		 | 9  | b   |
+
+ 	Scenario: Nearest - north-south way
+ 		Given the node map
+ 		 | 0 |   | 5 |
+ 		 | 1 | a | 6 |
+ 		 | 2 | x | 7 |
+ 		 | 3 | b | 8 |
+ 		 | 4 |   | 9 |
+         
+ 		And the ways
+ 		 | nodes |
+ 		 | ab    |
+
+ 		When I request nearest I should get
+ 		 | in | out |
+ 		 | 0  | a   |
+ 		 | 1  | a   |
+ 		 | 2  | x   |
+ 		 | 3  | b   |
+ 		 | 4  | b   |
+ 		 | 5  | a   |
+ 		 | 6  | a   |
+ 		 | 7  | x   |
+ 		 | 8  | b   |
+ 		 | 9  | b   |
+
+  	Scenario: Nearest - diagonal 1
+  		Given the node map
+ 		 | 8 |   | 4 |   |   |   |
+ 		 |   | a |   | 5 |   |   |
+ 		 | 0 |   | x |   | 6 |   |
+ 		 |   | 1 |   | y |   | 7 |
+ 		 |   |   | 2 |   | b |   |
+ 		 |   |   |   | 3 |   | 9 |
+
+  		And the ways
+  		 | nodes |
+  		 | ab    |
+
+  		When I request nearest I should get
+  		 | in | out |
+  		 | 0  | a   |
+  		 | 1  | x   |
+  		 | 2  | y   |
+  		 | 3  | b   |
+  		 | 4  | a   |
+  		 | 5  | x   |
+  		 | 6  | y   |
+  		 | 7  | b   |
+  		 | 8  | a   |
+  		 | 9  | b   |
+
+   	Scenario: Nearest - diagonal 2
+   		Given the node map
+  		 |   |   |   | 3 |   | 9 |
+  		 |   |   | 2 |   | b |   |
+  		 |   | 1 |   | y |   | 7 |
+  		 | 0 |   | x |   | 6 |   |
+  		 |   | a |   | 5 |   |   |
+  		 | 8 |   | 4 |   |   |   |
+
+   		And the ways
+   		 | nodes |
+   		 | ab    |
+
+   		When I request nearest I should get
+   		 | in | out |
+   		 | 0  | a   |
+   		 | 1  | x   |
+   		 | 2  | y   |
+   		 | 3  | b   |
+   		 | 4  | a   |
+   		 | 5  | x   |
+   		 | 6  | y   |
+   		 | 7  | b   |
+   		 | 8  | a   |
+   		 | 9  | b   |

features/step_definitions/data.rb

@@ -6,18 +6,25 @@ Given /^a grid size of (\d+) meters$/ do |meters|
   set_grid_size meters
 end
 
+Given /^the shortcuts$/ do |table|
+  table.hashes.each do |row|
+    shortcuts_hash[ row['key'] ] = row['value']
+  end
+end
+
 Given /^the node map$/ do |table|
   table.raw.each_with_index do |row,ri|
     row.each_with_index do |name,ci|
       unless name.empty?
         raise "*** node invalid name '#{name}', must be single characters" unless name.size == 1
         raise "*** invalid node name '#{name}', must me alphanumeric" unless name.match /[a-z0-9]/
-        raise "*** duplicate node '#{name}'" if name_node_hash[name]
-        node = OSM::Node.new make_osm_id, OSM_USER, OSM_TIMESTAMP, ORIGIN[0]+ci*@zoom, ORIGIN[1]-ri*@zoom 
-        node << { :name => name }
-        node.uid = OSM_UID
-        osm_db << node
-        name_node_hash[name] = node
+        if name.match /[a-z]/
+            raise "*** duplicate node '#{name}'" if name_node_hash[name]
+            add_osm_node name, *table_coord_to_lonlat(ci,ri)
+        else
+            raise "*** duplicate node '#{name}'" if location_hash[name]
+            add_location name, *table_coord_to_lonlat(ci,ri)
+        end
       end
     end
   end
@@ -26,21 +33,18 @@ end
 Given /^the node locations$/ do |table|
   table.hashes.each do |row|
     name = row['node']
-    raise "*** node invalid name '#{name}', must be single characters" unless name.size == 1
-    raise "*** invalid node name '#{name}', must me alphanumeric" unless name.match /[a-z0-9]/
-    raise "*** duplicate node '#{name}'" if name_node_hash[name]
-    node = OSM::Node.new make_osm_id, OSM_USER, OSM_TIMESTAMP, row['lon'].to_f, row['lat'].to_f 
-    node << { :name => name }
-    node.uid = OSM_UID
-    osm_db << node
-    name_node_hash[name] = node
+    raise "*** duplicate node '#{name}'" if find_node_by_name name
+    if name.match /[a-z]/
+        add_osm_node name, row['lon'].to_f, row['lat'].to_f 
+    else
+        add_location name, row['lon'].to_f, row['lat'].to_f 
+    end
   end
 end
 
 Given /^the nodes$/ do |table|
   table.hashes.each do |row|
     name = row.delete 'node'
-    raise "***invalid node name '#{c}', must be single characters" unless name.size == 1
     node = find_node_by_name(name)
     raise "*** unknown node '#{c}'" unless node
     node << row
@@ -55,8 +59,7 @@ Given /^the ways$/ do |table|
     nodes = row.delete 'nodes'
     raise "*** duplicate way '#{nodes}'" if name_way_hash[nodes]
     nodes.each_char do |c|
-      raise "***invalid node name '#{c}', must be single characters" unless c.size == 1
-      raise "*** ways cannot use numbered nodes, '#{name}'" unless c.match /[a-z]/
+      raise "*** ways can only use names a-z, '#{name}'" unless c.match /[a-z]/
       node = find_node_by_name(c)
       raise "*** unknown node '#{c}'" unless node
       way << node
@@ -90,14 +93,18 @@ Given /^the relations$/ do |table|
     relation = OSM::Relation.new make_osm_id, OSM_USER, OSM_TIMESTAMP
     row.each_pair do |key,value|
       if key =~ /^node:(.*)/
-        raise "***invalid relation node member '#{value}', must be single character" unless value.size == 1
-        node = find_node_by_name(value)
-        raise "*** unknown relation node member '#{value}'" unless node
-        relation << OSM::Member.new( 'node', node.id, $1 )
+        value.split(',').map { |v| v.strip }.each do |node_name|
+          raise "***invalid relation node member '#{node_name}', must be single character" unless node_name.size == 1
+          node = find_node_by_name(node_name)
+          raise "*** unknown relation node member '#{node_name}'" unless node
+          relation << OSM::Member.new( 'node', node.id, $1 )
+        end
       elsif key =~ /^way:(.*)/
-        way = find_way_by_name(value)
-        raise "*** unknown relation way member '#{value}'" unless way
-        relation << OSM::Member.new( 'way', way.id, $1 )
+        value.split(',').map { |v| v.strip }.each do |way_name|
+          way = find_way_by_name(way_name)
+          raise "*** unknown relation way member '#{way_name}'" unless way
+          relation << OSM::Member.new( 'way', way.id, $1 )
+        end
       elsif key =~ /^(.*):(.*)/
         raise "*** unknown relation member type '#{$1}', must be either 'node' or 'way'"
       else

features/step_definitions/nearest.rb

@@ -0,0 +1,51 @@
+When /^I request nearest I should get$/ do |table|
+  reprocess
+  actual = []
+  OSRMLauncher.new do
+    table.hashes.each_with_index do |row,ri|
+      in_node = find_node_by_name row['in']
+      raise "*** unknown in-node '#{row['in']}" unless in_node
+
+      out_node = find_node_by_name row['out']
+      raise "*** unknown out-node '#{row['out']}" unless out_node
+
+      response = request_nearest("#{in_node.lat},#{in_node.lon}")
+      if response.code == "200" && response.body.empty? == false
+        json = JSON.parse response.body
+        if json['status'] == 0
+          coord =  json['mapped_coordinate']
+        end
+      end
+      
+      got = {'in' => row['in'], 'out' => coord }
+      
+      ok = true
+      row.keys.each do |key|
+        if key=='out'
+          if FuzzyMatch.match_location coord, out_node
+            got[key] = row[key]
+          else
+            row[key] = "#{row[key]} [#{out_node.lat},#{out_node.lon}]"
+            ok = false
+          end
+        end
+      end
+      
+      unless ok
+        failed = { :attempt => 'nearest', :query => @query, :response => response }
+        log_fail row,got,[failed]
+      end
+      
+      actual << got
+    end
+  end
+  table.routing_diff! actual
+end
+
+When /^I request nearest (\d+) times I should get$/ do |n,table|
+  ok = true
+  n.to_i.times do
+    ok = false unless step "I request nearest I should get", table
+  end
+  ok
+end

features/step_definitions/routability.rb

@@ -12,22 +12,33 @@ Then /^routability should be$/ do |table|
       ['forw','backw','bothw'].each do |direction|
         if table.headers.include? direction
           if direction == 'forw' || direction == 'bothw'
-            response = request_route("#{ORIGIN[1]},#{ORIGIN[0]+(1+WAY_SPACING*i)*@zoom}","#{ORIGIN[1]},#{ORIGIN[0]+(3+WAY_SPACING*i)*@zoom}")
+            a = Location.new ORIGIN[0]+(1+WAY_SPACING*i)*@zoom, ORIGIN[1]
+            b = Location.new ORIGIN[0]+(3+WAY_SPACING*i)*@zoom, ORIGIN[1]
+            response = request_route [a,b]
           elsif direction == 'backw' || direction == 'bothw'
-            response = request_route("#{ORIGIN[1]},#{ORIGIN[0]+(3+WAY_SPACING*i)*@zoom}","#{ORIGIN[1]},#{ORIGIN[0]+(1+WAY_SPACING*i)*@zoom}")
+            a = Location.new ORIGIN[0]+(3+WAY_SPACING*i)*@zoom, ORIGIN[1]
+            b = Location.new ORIGIN[0]+(1+WAY_SPACING*i)*@zoom, ORIGIN[1]
+            response = request_route [a,b]
           end
+          want = shortcuts_hash[row[direction]] || row[direction]     #expand shortcuts
           got[direction] = route_status response
           json = JSON.parse(response.body)
           if got[direction].empty? == false
             route = way_list json['route_instructions']
             if route != "w#{i}"
-              got[direction] = "testing w#{i}, but got #{route}!?"
-            elsif row[direction] =~ /\d+s/
+              if row[direction].empty? == true
+                got[direction] = want
+              else
+                got[direction] = "testing w#{i}, but got #{route}!?"
+              end
+            elsif want =~ /^\d+s/
               time = json['route_summary']['total_time']
               got[direction] = "#{time}s"
             end
           end
-          if got[direction] != row[direction]
+          if FuzzyMatch.match got[direction], want
+            got[direction] = row[direction]
+          else
             attempts << { :attempt => direction, :query => @query, :response => response }
           end
         end

features/step_definitions/routing.rb

@@ -3,11 +3,41 @@ When /^I route I should get$/ do |table|
   actual = []
   OSRMLauncher.new do
     table.hashes.each_with_index do |row,ri|
-      from_node = @name_node_hash[ row['from'] ]
-      raise "*** unknown from-node '#{row['from']}" unless from_node
-      to_node = @name_node_hash[ row['to'] ]
-      raise "*** unknown to-node '#{row['to']}" unless to_node
-      response = request_route("#{from_node.lat},#{from_node.lon}", "#{to_node.lat},#{to_node.lon}")
+      waypoints = []
+      if row['from'] and row['to']
+        node = find_node_by_name(row['from'])
+        raise "*** unknown from-node '#{row['from']}" unless node
+        waypoints << node
+        
+        node = find_node_by_name(row['to'])
+        raise "*** unknown to-node '#{row['to']}" unless node
+        waypoints << node
+        
+        got = {'from' => row['from'], 'to' => row['to'] }
+      elsif row['waypoints']
+        row['waypoints'].split(',').each do |n|
+          node = find_node_by_name(n.strip)
+          raise "*** unknown waypoint node '#{n.strip}" unless node
+          waypoints << node
+        end
+        got = {'waypoints' => row['waypoints'] }
+      else
+        raise "*** no waypoints"
+      end
+        
+      params = {}
+      row.each_pair do |k,v|
+        if k =~ /param:(.*)/
+          if v=='(nil)'
+            params[$1]=nil
+          elsif v!=nil
+            params[$1]=v
+          end
+          got[k]=v
+        end
+      end
+            
+      response = request_route(waypoints, params)
       if response.code == "200" && response.body.empty? == false
         json = JSON.parse response.body
         if json['status'] == 0
@@ -15,10 +45,10 @@ When /^I route I should get$/ do |table|
           bearings = bearing_list json['route_instructions']
           compasses = compass_list json['route_instructions']
           turns = turn_list json['route_instructions']
+          modes = mode_list json['route_instructions']
         end
       end
       
-      got = {'from' => row['from'], 'to' => row['to'] }
       if table.headers.include? 'start'
         got['start'] = instructions ? json['route_summary']['start_point'] : nil
       end
@@ -46,34 +76,20 @@ When /^I route I should get$/ do |table|
         if table.headers.include? 'turns'
           got['turns'] = turns
         end
+        if table.headers.include? 'modes'
+          got['modes'] = modes
+        end
+        if table.headers.include? '#'   # comment column
+          got['#'] = row['#']           # copy value so it always match
+        end
       end
       
       ok = true
       row.keys.each do |key|
-        if row[key].match /(.*)\s+~(.+)%$/        #percentage range: 100 ~5%
-          margin = 1 - $2.to_f*0.01
-          from = $1.to_f*margin
-          to = $1.to_f/margin
-          if got[key].to_f >= from && got[key].to_f <= to
-            got[key] = row[key]
-          else
-            ok = false
-          end
-        elsif row[key].match /(.*)\s+\+\-(.+)$/   #absolute range: 100 +-5
-            margin = $2.to_f
-            from = $1.to_f-margin
-            to = $1.to_f+margin
-            if got[key].to_f >= from && got[key].to_f <= to
-              got[key] = row[key]
-            else
-              ok = false
-            end
-        elsif row[key] =~ /^\/(.*)\/$/          #regex: /a,b,.*/
-          if got[key] =~ /#{$1}/
-            got[key] = row[key]
-          end
+        if FuzzyMatch.match got[key], row[key]
+          got[key] = row[key]
         else
-          ok = row[key] == got[key]
+          ok = false
         end
       end
       
@@ -94,4 +110,4 @@ When /^I route (\d+) times I should get$/ do |n,table|
     ok = false unless step "I route I should get", table
   end
   ok
-end
+end