RhodeCode

          return Arc((u._id << 1) | 1);

        if (v._id - u._id == 1 && u._id % _width < _width - 1) {

          return Arc(((u._id / _width * (_width - 1) +

                       u._id % _width + _edge_limit) << 1) | 1);

        }

      } else {

        if (u._id - v._id == _width)

          return Arc(v._id << 1);

        if (u._id - v._id == 1 && v._id % _width < _width - 1) {

          return Arc((v._id / _width * (_width - 1) +

                       v._id % _width + _edge_limit) << 1);

        }

      }

      return INVALID;

    }

    class Node {

      friend class GridGraphBase;

    protected:

      int _id;

      Node(int id) : _id(id) {}

    public:

      Node() {}

      Node (Invalid) : _id(-1) {}

      bool operator==(const Node node) const {return _id == node._id;}

      bool operator!=(const Node node) const {return _id != node._id;}

      bool operator<(const Node node) const {return _id < node._id;}

    };

    class Edge {

      friend class GridGraphBase;

    protected:

      int _id;

      Edge(int id) : _id(id) {}

    public:

      Edge() {}

      Edge (Invalid) : _id(-1) {}

      bool operator==(const Edge edge) const {return _id == edge._id;}

      bool operator!=(const Edge edge) const {return _id != edge._id;}

      bool operator<(const Edge edge) const {return _id < edge._id;}

    };

    class Arc {

      friend class GridGraphBase;

    protected:

      int _id;

      Arc(int id) : _id(id) {}

    public:

      Arc() {}

      Arc (Invalid) : _id(-1) {}

      operator Edge() const { return _id != -1 ? Edge(_id >> 1) : INVALID; }

      bool operator==(const Arc arc) const {return _id == arc._id;}

      bool operator!=(const Arc arc) const {return _id != arc._id;}

      bool operator<(const Arc arc) const {return _id < arc._id;}

    };

    static bool direction(Arc arc) {

        return Arc((n._id << 1) | 1);

      } else {

        return INVALID;

      }

    }

    Arc down(Node n) const {

      if (n._id >= _width) {

        return Arc((n._id - _width) << 1);

      } else {

        return INVALID;

      }

    }

  private:

    int _width, _height;

    int _node_num, _edge_num;

    int _edge_limit;

  };

  typedef GraphExtender<GridGraphBase> ExtendedGridGraphBase;

  /// \ingroup graphs

  ///

  /// \brief Grid graph class

  ///

  /// This class implements a special graph type. The nodes of the

  /// graph can be indexed by two integer \c (i,j) value where \c i is

  /// in the \c [0..width()-1] range and j is in the \c

  /// [0..height()-1] range.  Two nodes are connected in the graph if

  /// the indexes differ exactly on one position and exactly one is

  /// get with \c pos(), \c col() and \c row() members. The outgoing

  /// arcs can be retrieved with the \c right(), \c up(), \c left()

  /// and \c down() functions, where the bottom-left corner is the

  /// origin.

  ///

  /// \image html grid_graph.png

  ///

  /// A short example about the basic usage:

  ///\code

  /// GridGraph graph(rows, cols);

  /// GridGraph::NodeMap<int> val(graph);

  /// for (int i = 0; i < graph.width(); ++i) {

  ///   for (int j = 0; j < graph.height(); ++j) {

  ///     val[graph(i, j)] = i + j;

  ///   }

  /// }

  ///\endcode

  ///

  /// "Graph" concept, and it also has an important extra feature

  class GridGraph : public ExtendedGridGraphBase {

  public:

    typedef ExtendedGridGraphBase Parent;

    /// \brief Map to get the indices of the nodes as dim2::Point<int>.

    ///

    /// Map to get the indices of the nodes as dim2::Point<int>.

    class IndexMap {

    public:

      /// \brief The key type of the map

      typedef GridGraph::Node Key;

      /// \brief The value type of the map

      typedef dim2::Point<int> Value;

      /// \brief Constructor

      ///

      /// Constructor

      IndexMap(const GridGraph& graph) : _graph(graph) {}

      /// \brief The subscript operator

      ///

      /// The subscript operator.

      Value operator[](Key key) const {

        return _graph.pos(key);

      }

    private:

      const GridGraph& _graph;

    };

    /// \brief Map to get the column of the nodes.

  Node

    n1 = g.addNode(),

    n2 = g.addNode(),

    n3 = g.addNode();

  Edge

    e1 = g.addEdge(n1, n2),

    e2 = g.addEdge(n2, n3);

  check(g.valid(n1), "Wrong validity check");

  check(g.valid(e1), "Wrong validity check");

  check(g.valid(g.direct(e1, true)), "Wrong validity check");

  g.erase(n1);

  check(!g.valid(n1), "Wrong validity check");

  check(g.valid(n2), "Wrong validity check");

  check(g.valid(n3), "Wrong validity check");

  check(!g.valid(e1), "Wrong validity check");

  check(g.valid(e2), "Wrong validity check");

  check(!g.valid(g.nodeFromId(-1)), "Wrong validity check");

  check(!g.valid(g.edgeFromId(-1)), "Wrong validity check");

  check(!g.valid(g.arcFromId(-1)), "Wrong validity check");

}

void checkGridGraph(int width, int height) {

  typedef GridGraph Graph;

  GRAPH_TYPEDEFS(Graph);

  Graph G(width, height);

  for (int i = 0; i < width; ++i) {

    for (int j = 0; j < height; ++j) {

      check(G.col(G(i, j)) == i, "Wrong column");

      check(G.row(G(i, j)) == j, "Wrong row");

      check(G.pos(G(i, j)).x == i, "Wrong column");

      check(G.pos(G(i, j)).y == j, "Wrong row");

    }

  }

  for (int j = 0; j < height; ++j) {

    for (int i = 0; i < width - 1; ++i) {

      check(G.source(G.right(G(i, j))) == G(i, j), "Wrong right");

      check(G.target(G.right(G(i, j))) == G(i + 1, j), "Wrong right");

    }

    check(G.right(G(width - 1, j)) == INVALID, "Wrong right");

  }

  for (int j = 0; j < height; ++j) {

    for (int i = 1; i < width; ++i) {

      check(G.source(G.left(G(i, j))) == G(i, j), "Wrong left");

      check(G.target(G.left(G(i, j))) == G(i - 1, j), "Wrong left");

    }

    check(G.left(G(0, j)) == INVALID, "Wrong left");

  }

  for (int i = 0; i < width; ++i) {

    for (int j = 0; j < height - 1; ++j) {

      check(G.source(G.up(G(i, j))) == G(i, j), "Wrong up");

      check(G.target(G.up(G(i, j))) == G(i, j + 1), "Wrong up");

    }

    check(G.up(G(i, height - 1)) == INVALID, "Wrong up");