Propagating turn info (not yet finished)

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 _target;
+    NodeID _source:31;
+    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 {