Queries are now handled by a static graph which means less RAM usage and faster queries.

2010-07-14 12:55:53 +00:00
parent 18b278fe1d
commit fa5a042071
5 changed files with 216 additions and 44 deletions
@@ -16,50 +16,70 @@ 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 _NODE_COORDS_H
 #define _NODE_COORDS_H

+#include <limits>

 template<typename NodeT>
 struct NodeCoords {
+    typedef unsigned key_type;
+
+
    NodeCoords(int _lat, int _lon, NodeT _id) : lat(_lat), lon(_lon), id(_id) {}
    NodeCoords() : lat(UINT_MAX), lon(UINT_MAX), id(UINT_MAX) {}
    int lat;
    int lon;
    unsigned int id;
+
+    static NodeCoords<NodeT> min_value()
+    {
+        return NodeCoords<NodeT>(0,0,numeric_limits<NodeT>::min());
+    }
+    static NodeCoords<NodeT> max_value()
+    {
+        return NodeCoords<NodeT>(numeric_limits<int>::max(), numeric_limits<int>::max(), numeric_limits<NodeT>::max());
+    }
+
 };

+template<typename NodeT>
+bool operator < (const NodeCoords<NodeT> & a, const NodeCoords<NodeT> & b)
+{
+    return a.id < b.id;
+}
+
 struct duplet
+{
+    typedef int value_type;
+
+    inline value_type operator[](int const N) const { return d[N]; }
+
+    inline bool operator==(duplet const& other) const
+                       {
+        return this->d[0] == other.d[0] && this->d[1] == other.d[1];
+                       }
+
+    inline bool operator!=(duplet const& other) const
+                       {
+        return this->d[0] != other.d[0] || this->d[1] != other.d[1];
+                       }
+
+    friend std::ostream & operator<<(std::ostream & o, duplet const& d)
    {
-       typedef int value_type;
-
-       inline value_type operator[](int const N) const { return d[N]; }
-
-       inline bool operator==(duplet const& other) const
-       {
-          return this->d[0] == other.d[0] && this->d[1] == other.d[1];
-       }
-
-       inline bool operator!=(duplet const& other) const
-       {
-          return this->d[0] != other.d[0] || this->d[1] != other.d[1];
-       }
-
-       friend std::ostream & operator<<(std::ostream & o, duplet const& d)
-       {
-          return o << "(" << d[0] << "," << d[1] << ")";
-       }
-       duplet(unsigned _id, int x, int y)
-       {
-           id = _id;
-           d[0] = x;
-           d[1] = y;
-       }
-       unsigned int id;
-       value_type d[2];
-    };
+        return o << "(" << d[0] << "," << d[1] << ")";
+    }
+    duplet(unsigned _id, int x, int y)
+    {
+        id = _id;
+        d[0] = x;
+        d[1] = y;
+    }
+    unsigned int id;
+    value_type d[2];
+};

 inline double return_dup( duplet d, int k ) { return d[k]; }

@@ -0,0 +1,151 @@
+/*
+    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 STATICGRAPH_H_INCLUDED
+#define STATICGRAPH_H_INCLUDED
+
+#include <vector>
+#include <algorithm>
+
+#include "../typedefs.h"
+
+template< typename EdgeData>
+class StaticGraph {
+public:
+    typedef NodeID NodeIterator;
+    typedef NodeID EdgeIterator;
+
+    class InputEdge {
+    public:
+        EdgeData data;
+        NodeIterator source;
+        NodeIterator target;
+        bool operator<( const InputEdge& right ) const {
+            if ( source != right.source )
+                return source < right.source;
+            return target < right.target;
+        }
+    };
+
+    StaticGraph( int nodes, std::vector< InputEdge > &graph ) {
+
+        std::sort( graph.begin(), graph.end() );
+        _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
+            //            _nodes[node].edges = edge - lastEdge;
+            //            _nodes[node].size =  edge - lastEdge;
+            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].firstEdge + _nodes[node].edges; i != e; ++i ) {
+            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;
+    }
+
+    unsigned GetNumberOfEdges() const {
+        return _numEdges;
+    }
+
+    unsigned GetOutDegree( const NodeIterator &n ) const {
+        return _nodes[n].edges;
+    }
+
+    NodeIterator GetTarget( const EdgeIterator &e ) const {
+        return NodeIterator( _edges[e].target );
+    }
+
+    EdgeData &GetEdgeData( const EdgeIterator &e ) {
+        return _edges[e].data;
+    }
+    const EdgeData &GetEdgeData( const EdgeIterator &e ) const {
+        return _edges[e].data;
+    }
+
+    EdgeIterator BeginEdges( const NodeIterator &n ) const {
+        //assert( EndEdges( n ) - EdgeIterator( _nodes[n].firstEdge ) <= 100 );
+        return EdgeIterator( _nodes[n].firstEdge );
+    }
+
+    EdgeIterator EndEdges( const NodeIterator &n ) const {
+        return EdgeIterator( _nodes[n+1].firstEdge );
+    }
+
+    //searches for a specific edge
+    EdgeIterator FindEdge( const NodeIterator &from, const NodeIterator &to ) const {
+        EdgeIterator smallestEdge = SPECIAL_EDGEID;
+        EdgeWeight smallestWeight = UINT_MAX;
+        for ( EdgeIterator edge = BeginEdges( from ); edge < EndEdges(from); edge++ )
+        {
+            const NodeID target = GetTarget(edge);
+            const EdgeWeight weight = GetEdgeData(edge).distance;
+            {
+                if(target == to && weight < smallestWeight)
+                {
+                    smallestEdge = edge; smallestWeight = weight;
+                }
+            }
+        }
+        return smallestEdge;
+    }
+
+
+private:
+
+    struct _StrNode {
+        //index of the first edge
+        EdgeIterator firstEdge;
+        //amount of edges
+        //        unsigned edges;
+        //        unsigned size;
+    };
+
+    struct _StrEdge {
+        NodeID target;
+        EdgeData data;
+    };
+
+    NodeIterator _numNodes;
+    EdgeIterator _numEdges;
+
+    std::vector< _StrNode > _nodes;
+    std::vector< _StrEdge > _edges;
+};
+
+#endif // STATICGRAPH_H_INCLUDED