Propagating turn info (not yet finished)

Contractor/Contractor.h

@@ -59,7 +59,9 @@ private:
         bool shortcut : 1;
         bool forward : 1;
         bool backward : 1;
-        short type;
+        short type:6;
+        bool forwardTurn:1;
+        bool backwardTurn:1;
         _MiddleName middleName;
     } data;
 
@@ -209,6 +211,8 @@ public:
             std::swap( edge.source, edge.target );
             edge.data.forward = i->isBackward();
             edge.data.backward = i->isForward();
+            edge.data.forwardTurn = i->isForwardTurn();
+            edge.data.backwardTurn = i->isBackwardTurn();
             edges.push_back( edge );
         }
         std::vector< InputEdge >().swap( inputEdges ); //free memory
@@ -296,25 +300,6 @@ public:
         }
     }
 
-    /* check if its possible to turn at the end of an edge */
-    template< class InputEdge >
-    void ComputeTurnInfoVector( std::vector< InputEdge >& inputEdges ) {
-        for(unsigned n = 0; n < inputEdges.size(); n++) {
-            if(inputEdges[n].data.forward) {
-                NodeID target = inputEdges[n].target;
-                if(_graph->BeginEdges(target)+1 < _graph->EndEdges(target)) {
-                    inputEdges[n].data.forwardTurn = true;
-                }
-            }
-            if(inputEdges[n].data.backward) {
-                NodeID source = inputEdges[n].source;
-                if(_graph->BeginEdges(source)+1 < _graph->EndEdges(source)) {
-                    inputEdges[n].data.backwardTurn = true;
-                }
-            }
-        }
-    }
-
     void Run() {
         const NodeID numberOfNodes = _graph->GetNumberOfNodes();
         _LogData log;
@@ -495,6 +480,8 @@ public:
                 }
 
                 newEdge.data.forward = data.forward;
+                newEdge.data.forwardTurn = data.forwardTurn;
+                newEdge.data.backwardTurn = data.backwardTurn;
                 newEdge.data.backward = data.backward;
                 edges.push_back( newEdge );
             }

DataStructures/ImportEdge.h

@@ -44,7 +44,8 @@ public:
     /** Default constructor. target and weight are set to 0.*/
     Edge() { assert(false); } //shall not be used.
 
-    explicit Edge(NodeID s, NodeID t, NodeID n, EdgeWeight w, bool f, bool b, short ty) : _source(s), _target(t), _name(n), _weight(w), forward(f), backward(b), _type(ty) { assert(ty >= 0); }
+    explicit Edge(NodeID s, NodeID t, NodeID n, EdgeWeight w, bool f, bool b, short ty) :
+            _source(s), _target(t), _name(n), _weight(w), forward(f), backward(b), _type(ty), forwardTurn(false), backwardTurn(false) { assert(ty >= 0); }
 
     NodeID target() const {return _target; }
     NodeID source() const {return _source; }
@@ -56,13 +57,21 @@ public:
     bool isForward() const { return forward; }
     bool isLocatable() const { return _type != 14; }
 
+    bool isForwardTurn() const { return forwardTurn; }
+    bool isBackwardTurn() const { return backwardTurn; }
+
+    void setForwardTurn(bool f) { forwardTurn = f; }
+    void setBackwardTurn(bool b) { backwardTurn = b; }
+
 private:
-    NodeID _source;
+    NodeID _source:31;
-    NodeID _target;
+    NodeID _target:31;
     NodeID _name:31;
     EdgeWeight _weight:31;
     bool forward:1;
     bool backward:1;
+    bool forwardTurn:1;
+    bool backwardTurn:1;
     short _type;
 };
 

DataStructures/StaticGraph.h

@@ -29,6 +29,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #endif
 
 #include "../typedefs.h"
+#include "ImportEdge.h"
 
 template< typename EdgeData>
 class StaticGraph {
@@ -79,6 +80,39 @@ public:
         }
     }
 
+    //Attention: Use this constructor only to if you know what you are doing
+    //           Edges do not have any weight. _edges[i].data is undefined!
+    StaticGraph( int nodes, std::vector< ImportEdge > &graph ) {
+#ifdef _GLIBCXX_PARALLEL
+        __gnu_parallel::sort( graph.begin(), graph.end() );
+#else
+        std::sort( graph.begin(), graph.end() );
+#endif
+        _numNodes = nodes;
+        _numEdges = ( EdgeIterator ) graph.size();
+        _nodes.resize( _numNodes + 1);
+        EdgeIterator edge = 0;
+        EdgeIterator position = 0;
+        for ( NodeIterator node = 0; node <= _numNodes; ++node ) {
+            EdgeIterator lastEdge = edge;
+            while ( edge < _numEdges && graph[edge].source() == node ) {
+                ++edge;
+            }
+            _nodes[node].firstEdge = position; //=edge
+            position += edge - lastEdge; //remove
+        }
+        _edges.resize( position ); //(edge)
+        edge = 0;
+        for ( NodeIterator node = 0; node < _numNodes; ++node ) {
+            for ( EdgeIterator i = _nodes[node].firstEdge, e = _nodes[node+1].firstEdge; i != e; ++i ) {
+                _edges[i].target = graph[edge].target();
+//                _edges[i].data = graph[edge].data;
+//                assert(_edges[i].data.distance > 0);
+                edge++;
+            }
+        }
+    }
+
     unsigned GetNumberOfNodes() const {
         return _numNodes;
     }
@@ -129,6 +163,36 @@ public:
         return smallestEdge;
     }
 
+
+    /* check if its possible to turn at the end of an edge */
+    template< class InputEdge >
+    void ComputeTurnInformation( std::vector< InputEdge >& inputEdges ) {
+        unsigned count = 0;
+        for(unsigned n = 0; n < inputEdges.size(); n++) {
+            NodeIterator target = inputEdges[n].target();
+            NodeIterator source = inputEdges[n].source();
+
+            if(inputEdges[n].isForward() ) {
+                EdgeIterator begin = BeginEdges(target);
+                EdgeIterator end = EndEdges(target);
+                if( begin + ( inputEdges[n].isBackward() ? 2 : 1 ) < end ) {
+                    inputEdges[n].setForwardTurn( true );
+                    count++;
+                }
+            }
+
+            if(inputEdges[n].isBackward() ) {
+                EdgeIterator begin = BeginEdges(source);
+                EdgeIterator end = EndEdges(source);
+                if( begin + ( inputEdges[n].isForward() ? 2 : 1 ) < end ) {
+                    inputEdges[n].setBackwardTurn( true );
+                    count ++;
+                }
+            }
+        }
+        cout << "allowed turns: " << count << endl;
+    }
+
 private:
 
     struct _StrNode {

HttpServer/request_handler.h

@@ -233,8 +233,8 @@ private:
         output = string;
     }
 
-    // precision: Nachkommastellen
+    // precision:  position after decimal point
-    // length: Maximallänge inklusive Komma
+    // length: maximum number of digits including comma and decimals
     template< int length, int precision >
     inline char* printInt( char* buffer, int value )
     {
@@ -337,13 +337,13 @@ private:
                     tmp += /* " (" << angle << ")*/"drive ahead, ";
                 } else if (angle > 290 && angle <= 360) {
                     tmp += /*" (" << angle << ")*/ "turn sharp left, ";
-                } else if (angle > 245 && angle <= 290) {
+                } else if (angle > 230 && angle <= 290) {
                     tmp += /*" (" << angle << ")*/ "turn left, ";
-                } else if (angle > 200 && angle <= 245) {
+                } else if (angle > 200 && angle <= 230) {
                     tmp += /*" (" << angle << ") */"bear left, ";
-                } else if (angle > 115 && angle <= 160) {
+                } else if (angle > 130 && angle <= 160) {
                     tmp += /*" (" << angle << ") */"bear right, ";
-                } else if (angle > 70 && angle <= 115) {
+                } else if (angle > 70 && angle <= 130) {
                     tmp += /*" (" << angle << ") */"turn right, ";
                 } else {
                     tmp += /*" (" << angle << ") */"turn sharp right, ";
@@ -363,8 +363,12 @@ private:
         numberString << type;
         tmp += numberString.str();
         numberString.str("");
+        tmp += ", id: ";
+        numberString << nameID;
+        tmp += numberString.str();
+        numberString.str("");
         tmp += ")</name>\n <Description> drive for ";
-        numberString << (previous.lat, previous.lon, phantomNodes->targetCoord.lat, phantomNodes->targetCoord.lon) + tempDist;
+        numberString << ApproximateDistance(previous.lat, previous.lon, phantomNodes->targetCoord.lat, phantomNodes->targetCoord.lon) + tempDist;
         tmp += numberString.str();
         numberString.str("");
         tmp += "m</Description>\n ";

createHierarchy.cpp

@@ -51,6 +51,7 @@ using namespace std;
 
 typedef ContractionCleanup::Edge::EdgeData EdgeData;
 typedef DynamicGraph<EdgeData>::InputEdge GridEdge;
+typedef StaticGraph<EdgeData>::InputEdge StaticEdge;
 typedef NNGrid::NNGrid<true> WritableGrid;
 
 vector<NodeInfo> * int2ExtNodeMap = new vector<NodeInfo>();
@@ -73,6 +74,13 @@ int main (int argc, char *argv[])
     const NodeID n = readOSRMGraphFromStream(in, edgeList, int2ExtNodeMap);
     in.close();
 
+    StaticGraph<EdgeData> * staticGraph = new StaticGraph<EdgeData>( n, edgeList );
+
+    cout << "computing turn vector info ..." << flush;
+    staticGraph->ComputeTurnInformation( edgeList );
+    cout << "ok" << endl;
+    delete staticGraph;
+
     char nodeOut[1024];
     char edgeOut[1024];
     char ramIndexOut[1024];
@@ -127,7 +135,7 @@ int main (int argc, char *argv[])
 
     cout << "initializing contractor ..." << flush;
     Contractor* contractor = new Contractor( n, edgeList );
-    vector<ImportEdge>(edgeList.begin(), edgeList.end()).swap(edgeList); //remove excess candidates.
+
     contractor->Run();
 
     cout << "checking data sanity ..." << flush;
@@ -142,10 +150,6 @@ int main (int argc, char *argv[])
     std::vector< GridEdge> cleanedEdgeList;
     cleanup->GetData(cleanedEdgeList);
 
-    cout << "computing turn vector info ..." << flush;
-    contractor->ComputeTurnInfoVector(cleanedEdgeList);
-    cout << "ok" << endl;
-
     ofstream edgeOutFile(edgeOut, ios::binary);
 
     //Serializing the edge list.
@@ -177,6 +181,7 @@ int main (int argc, char *argv[])
         edgeOutFile.write((char *)&(distance), sizeof(int));
         edgeOutFile.write((char *)&(forwardTurn), sizeof(bool));
         edgeOutFile.write((char *)&(backwardTurn), sizeof(bool));
+        assert(forwardTurn && backwardTurn);
         edgeOutFile.write((char *)&(shortcut), sizeof(bool));
         edgeOutFile.write((char *)&(forward), sizeof(bool));
         edgeOutFile.write((char *)&(backward), sizeof(bool));