COIN-OR::LEMON - Graph Library

Ticket #363: lemon-sikgraf2_2c0edf00dc8f.patch

File lemon-sikgraf2_2c0edf00dc8f.patch, 46.1 KB (added by gyorokp, 9 years ago)
  • lemon/graph_to_eps.h

    # HG changeset patch
    # User Peter Gyorok
    # Date 1285418159 -7200
    # Node ID 2c0edf00dc8ff8bdf85187c590b17d2a355b2d03
    # Parent  10d57978f9003ad2839583e71265b72b30b884b1
    PlanarGraph and PlaneGraph related fixes (#363)
    
    diff -r 10d57978f900 -r 2c0edf00dc8f lemon/graph_to_eps.h
    a b  
    662662public:
    663663  ~GraphToEps() { }
    664664
     665private:
    665666  template<typename GR, typename D>
    666667  void edgeToEps(const GR &g, std::ostream &os, const typename GR::Arc e,
    667668    const Color &col, double width, D t) {
     
    674675  }
    675676
    676677  template<typename D>
    677   void inner_run(D t) {
     678  void start(D t) {
    678679    const double EPSILON=1e-9;
    679680    if(dontPrint) return;
    680681
     
    10761077    if(_pleaseRemoveOsStream) {delete &os;}
    10771078  }
    10781079
     1080public:
    10791081  ///Draws the graph.
    10801082
    10811083  ///Like other functions using
     
    10831085  ///this function calls the algorithm itself, i.e. in this case
    10841086  ///it draws the graph.
    10851087  void run(int i = 0) {
    1086     this->inner_run(i); //for normal graphs
     1088    this->start(i); //for normal graphs
    10871089  }
    10881090
    10891091  void run(bool b) {
    1090     this->inner_run(b); //for plane graphs with custom edge shape support
     1092    this->start(b); //for plane graphs with custom edge shape support
    10911093  }
    10921094
    10931095  ///\name Aliases
  • lemon/planar_graph.h

    diff -r 10d57978f900 -r 2c0edf00dc8f lemon/planar_graph.h
    a b  
    2121
    2222///\ingroup graphs
    2323///\file
    24 ///\brief PlanarGraph classes. UNDER CONSTRUCTION.
     24///\brief PlanarGraph classes.
    2525
    2626#include <lemon/core.h>
    2727#include <lemon/error.h>
     
    359359
    360360    void firstCcwF(Arc &e, const Face &f) const {
    361361      e.id = faces[f.id].first_arc;
     362      setToOpposite(e);
    362363      turnRight(e);
    363       setToOpposite(e);
    364364    }
    365365    void nextCcwF(Arc &e) const {
    366366      if (e.id == faces[arcs[e.id].left_face].first_arc) e = INVALID;
    367367      else {
     368        setToOpposite(e);
    368369        turnRight(e);
    369         setToOpposite(e);
    370370      }
    371371    }
    372372    void firstCwF(Arc &e, const Face &f) const {
     
    379379    }
    380380
    381381    void firstInF(Arc &e, const Face &f) const {
    382       e.id = faces[f.id].first_arc;
     382      e.id = faces[f.id].first_arc ^ 1;
     383      turnRight(e);
     384      setToOpposite(e);
    383385    }
    384386    void nextInF(Arc &e) const {
    385       setToOpposite(e);
    386       turnRight(e);
    387       if (e.id == faces[arcs[e.id].left_face].first_arc) e = INVALID;
    388     }
    389     void lastInF(Arc &e, const Face &f) const {
    390       e.id = faces[f.id].first_arc;
    391       setToOpposite(e);
    392       turnRight(e);
    393     }
    394     void prevInF(Arc &e) const {
    395       if (e.id == faces[arcs[e.id].left_face].first_arc) {
     387      if (e.id == (faces[arcs[e.id ^ 1].left_face].first_arc ^ 1)) {
    396388        e = INVALID;
    397389        return;
    398390      }
     391      turnRight(e);
    399392      setToOpposite(e);
    400       turnRight(e);
     393    }
     394    void lastInF(Arc &e, const Face &f) const {
     395      e.id = faces[f.id].first_arc ^ 1;
     396    }
     397    void prevInF(Arc &e) const {
     398      setToOpposite(e);
     399      turnLeft(e);
     400      if (e.id == (faces[arcs[e.id ^ 1].left_face].first_arc ^ 1)) e = INVALID;
    401401    }
    402402
    403403    void firstOutF(Arc &e, const Face &f) const {
     
    522522    }
    523523
    524524    Node addNode() {
    525       int n = link_node();
     525      int n = linkNode();
    526526
    527527      nodes[n].component = addComponent();
    528528      components[nodes[n].component].num_nodes = 1;
     
    540540          left_face && nodes[u.id].component == nodes[v.id].component) return
    541541          INVALID;
    542542
    543       int n = link_edge();
     543      int n = linkEdge();
    544544
    545545      arcs[n].target = u.id;
    546546      arcs[n | 1].target = v.id;
     
    585585        faces[f.id].first_arc = n | 1;
    586586        faces[oldf].first_arc = n;
    587587        Arc arc(n | 1);
    588         wall_paint(arc,f.id,arc);
     588        wallPaint(arc,f.id,arc);
    589589        if (nodes[v.id].component != nodes[u.id].component) {
    590590          erase(Face(oldf));
    591591          erase(Face(oldfb));
    592592          if (components[ca].num_nodes > components[cb].num_nodes) {
    593             component_relabel(v,ca);
     593            componentRelabel(v,ca);
    594594            eraseComponent(cb);
    595595          } else {
    596             component_relabel(u,cb);
     596            componentRelabel(u,cb);
    597597            eraseComponent(ca);
    598598          }
    599599        }
     
    638638      eraseComponent(nodes[n].component);
    639639      erase(Face(nodes[n].outer_face));
    640640
    641       unlink_node(n);
     641      unlinkNode(n);
    642642    }
    643643
    644644    void erase(const Edge& edge) {
     
    658658      bool comp_split = false;
    659659      if (fr != fl) {
    660660        Arc arc(faces[fr].first_arc);
    661         wall_paint(arc,fl,arc);
     661        wallPaint(arc,fl,arc);
    662662        if ((faces[fl].first_arc | 1) == (n | 1))
    663663          faces[fl].first_arc = faces[fr].first_arc;
    664664        erase(Face(fr));
     
    671671          ed.id ^= 1;
    672672          turnRightF(arc);
    673673          Face f = addFace();
    674           wall_paint(arc,f.id,ed);
     674          wallPaint(arc,f.id,ed);
    675675          faces[f.id].first_arc = arc.id;
    676676          turnRightF(ed);
    677677          faces[fr].first_arc = ed.id;
     
    681681      if (arcs[n].next_out != -1) {
    682682        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
    683683      } else {
    684         nodes[arcs[n].target].last_out = arcs[n].prev_out;
     684        nodes[arcs[n | 1].target].last_out = arcs[n].prev_out;
    685685      }
    686686
    687687      if (arcs[n].prev_out != -1) {
     
    693693      if (arcs[n | 1].next_out != -1) {
    694694        arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
    695695      } else {
    696         nodes[arcs[n | 1].target].last_out = arcs[n | 1].prev_out;
     696        nodes[arcs[n].target].last_out = arcs[n | 1].prev_out;
    697697      }
    698698
    699699      if (arcs[n | 1].prev_out != -1) {
     
    702702        nodes[arcs[n].target].first_out = arcs[n | 1].next_out;
    703703      }
    704704
    705       unlink_edge(edge);
     705      unlinkEdge(edge);
    706706
    707       if (comp_split) component_relabel(Node(arcs[n | 1].target),
     707      if (comp_split) componentRelabel(Node(arcs[n | 1].target),
    708708        addComponent());
    709709      if (nodes[arcs[n].target].first_out == -1 && nodes[arcs[n | 1].target].
    710710              first_out == -1) {
     
    736736    Node split(Edge e) {
    737737      Node v;
    738738      Edge e2;
    739       inner_split1(v,e2);
    740       return inner_split2(e,v,e2);
     739      innerSplit1(v,e2);
     740      return innerSplit2(e,v,e2);
    741741    }
    742742
    743743    Node split(Node n1, Edge e1, Edge e2, bool b) {
    744744      Node n2;
    745       inner_split1(n1,n2);
     745      innerSplit1(n1,n2);
    746746      Edge a3;
    747       inner_split2(n1,n2,e1,e2,b,a3);
     747      innerSplit2(n1,n2,e1,e2,b,a3);
    748748      if (!b && a3 != INVALID) erase(a3);
    749749      return n2;
    750750    }
     
    754754      Node n2 = v(e);
    755755      Node nd;
    756756      bool simple;
    757       inner_contract1(n1,n2,nd,simple);
    758       inner_contract2(e,n1,n2,nd,simple);
     757      innerContract1(n1,n2,nd,simple);
     758      innerContract2(e,n1,n2,nd,simple);
    759759    }
    760760
    761761  protected:
     
    763763    //Adds a node to the linked list and sets default properties. Used by
    764764    //addNode and other functions that take care of the planar properties by
    765765    //themselves.
    766     int link_node() {
     766    int linkNode() {
    767767      int n;
    768768      if (first_free_node==-1) {
    769769        n = nodes.size();
     
    784784    //Removes a node from the linked list. Used by
    785785    //erase(Node) and other functions that take care of the planar properties by
    786786    //themselves.
    787     void unlink_node(int n) {
     787    void unlinkNode(int n) {
    788788      if (nodes[n].next != -1) {
    789789        nodes[nodes[n].next].prev = nodes[n].prev;
    790790      }
     
    803803    //Adds an edge to the linked list. Used by
    804804    //addEdge and other functions that take care of the planar properties by
    805805    //themselves.
    806     int link_edge() {
     806    int linkEdge() {
    807807      int n;
    808808      if (first_free_arc == -1) {
    809809        n = arcs.size();
     
    819819    //Removes an edge from the linked list. Used by
    820820    //erase(Edge) and other functions that take care of the planar properties by
    821821    //themselves.
    822     void unlink_edge(Edge e) {
     822    void unlinkEdge(Edge e) {
    823823      int n = e.id*2;
    824824      arcs[n].next_out = first_free_arc;
    825825      first_free_arc = n;
     
    828828    }
    829829
    830830    //Primitives of split(Edge)
    831     void inner_split1(Node &v, Edge &e2) {
    832       v = Node(link_node());
    833       e2 = Arc(link_edge());
     831    void innerSplit1(Node &v, Edge &e2) {
     832      v = Node(linkNode());
     833      e2 = Arc(linkEdge());
    834834    }
    835835
    836     Node inner_split2(Edge e, Node v, Edge e2) {
     836    Node innerSplit2(Edge e, Node v, Edge e2) {
    837837      Arc a(e.id*2);
    838838      int b = e2.id*2;
    839839      nodes[v.id].component = nodes[arcs[a.id].target].component;
     
    864864    }
    865865
    866866    //Primitives of contract(Edge)
    867     void inner_contract1(Node n1, Node n2, Node &to_delete, bool &simple) {
     867    void innerContract1(Node n1, Node n2, Node &to_delete, bool &simple) {
    868868      if (nodes[n1.id].first_out == nodes[n1.id].last_out) {
    869869        simple = true;
    870870        to_delete = n1;
     
    877877      }
    878878    }
    879879
    880     void inner_contract2(Edge e, Node n1, Node n2, Node &to_delete, bool
     880    void innerContract2(Edge e, Node n1, Node n2, Node &to_delete, bool
    881881      &simple) {
    882882      if (simple) {
    883883        erase(e);
     
    921921      }
    922922      arcs[arcs[a.id].prev_out].next_out = arcs[a.id | 1].next_out;
    923923
    924       unlink_edge(e);
     924      unlinkEdge(e);
    925925      --components[nodes[n2.id].component].num_nodes;
    926       unlink_node(n2.id);
     926      unlinkNode(n2.id);
    927927    }
    928928
    929929    //Primitives of split(Node)
    930     void inner_split1(Node n1, Node &n2) {
    931       n2 = Node(link_node());
     930    void innerSplit1(Node n1, Node &n2) {
     931      n2 = Node(linkNode());
    932932    }
    933933
    934     void inner_split2(Node n1, Node n2, Edge e1, Edge e2, bool b, Edge &e3) {
     934    void innerSplit2(Node n1, Node n2, Edge e1, Edge e2, bool b, Edge &e3) {
    935935      e3 = INVALID;
    936936      if (nodes[n1.id].first_out == -1) {
    937937        if (b) e3 = addEdge(n1,n2,INVALID,INVALID);
     
    945945      if (arcs[a1.id].target != n1.id) a1.id |= 1;
    946946      Arc a2(e2.id*2);
    947947      if (arcs[a2.id].target != n1.id) a2.id |= 1;
    948       Arc a3(link_edge());
     948      Arc a3(linkEdge());
    949949      e3 = a3;
    950950      arcs[a3.id].target = n1.id;
    951951      arcs[a3.id | 1].target = n2.id;
     
    973973    }
    974974
    975975    //Relabels the "wall" of a face with a new face ID.
    976     void wall_paint(Arc arc, int f_id, Arc ed) {
     976    void wallPaint(Arc arc, int f_id, Arc ed) {
    977977      do {
    978978        arcs[arc.id].left_face = f_id;
    979979        turnRightF(arc);
     
    981981    }
    982982
    983983    //Relabels a component with a new component ID.
    984     void component_relabel(Node node, int comp_id) {
     984    void componentRelabel(Node node, int comp_id) {
    985985      std::vector<int> ns(nodes.size());
    986986      std::list<int> q;
    987987      q.push_back(node.id);
     
    11371137      }
    11381138    }
    11391139#endif
    1140 
    11411140  };
    11421141
    11431142  // Face counting:
     
    13021301    };
    13031302
    13041303
    1305   /// Iterator class for the faces.
     1304                /// Iterator class for the faces.
    13061305
    1307   /// This iterator goes through the faces of a planar graph.
    1308   class FaceIt : public Face {
     1306                /// This iterator goes through the faces of a planar graph.
     1307                class FaceIt : public Face {
    13091308      const Graph* _graph;
    13101309    public:
    13111310
     
    13251324        return *this;
    13261325      }
    13271326
    1328     };
     1327                };
    13291328
    13301329
    1331   /// Iterator class for the common faces of two nodes
     1330                /// Iterator class for the common faces of two nodes
    13321331
    1333   /// This iterator goes through the common faces of two nodes
    1334   class CommonFacesIt : public Face {
     1332                /// This iterator goes through the common faces of two nodes
     1333                class CommonFacesIt : public Face {
    13351334      const Graph* _graph;
    13361335      const Node _n1, _n2;
    13371336      std::set<Face> _f1, _f2;
     
    13711370        return *this;
    13721371      }
    13731372
    1374     };
     1373                };
    13751374
    1376   /// Iterator class for the common nodes of two facess
     1375                /// Iterator class for the common nodes of two facess
    13771376
    1378   /// This iterator goes through the common nodes of two faces
    1379   class CommonNodesIt : public Node {
     1377                /// This iterator goes through the common nodes of two faces
     1378                class CommonNodesIt : public Node {
    13801379      const Graph* _graph;
    13811380      const Face _f1, _f2;
    13821381      std::set<Node> _ns1,_ns2;
     
    14161415        return *this;
    14171416      }
    14181417
    1419     };
     1418                };
    14201419
    1421   /// Iterator class for the arcs on the boundary of a face.
     1420                /// This iterator goes through the arcs on the boundary of a face counter clockwise.
     1421                class CcwBoundaryArcIt : public Arc {
     1422      const Graph* _graph;
     1423      Face _face;
     1424      Arc f_arc;
     1425    public:
    14221426
    1423   /// This iterator goes through the arcs on the boundary of a face clockwise.
    1424   class CwBoundaryArcIt : public Arc {
     1427      CcwBoundaryArcIt() { }
     1428
     1429      CcwBoundaryArcIt(Invalid i) : Arc(i) { }
     1430
     1431      CcwBoundaryArcIt(const Graph& graph, const Face& face)
     1432          : _graph(&graph), _face(face) {
     1433        _graph->firstCcwF(static_cast<Arc&>(*this),face);
     1434        f_arc = *this;
     1435      }
     1436
     1437      CcwBoundaryArcIt(const Graph& graph, const Arc& arc)
     1438          : Arc(arc), _graph(&graph) {}
     1439
     1440      CcwBoundaryArcIt& operator++() {
     1441        _graph->nextCcwF(*this);
     1442        return *this;
     1443      }
     1444
     1445                };
     1446
     1447                /// Iterator class for the arcs on the boundary of a face.
     1448
     1449                /// This iterator goes through the arcs on the boundary of a face clockwise.
     1450                class CwBoundaryArcIt : public Arc {
    14251451      const Graph* _graph;
    14261452      Face _face;
    14271453      Arc f_arc;
     
    14451471        return *this;
    14461472      }
    14471473
    1448     };
     1474                };
    14491475
    1450   /// Iterator class for the arcs around a node.
     1476                /// Iterator class for the outgoing arcs of a node.
    14511477
    1452   /// This iterator goes through the arcs around a node anticlockwise.
    1453   class CcwArcIt : public Arc {
     1478                /// This iterator goes through the outgoing arcs of a node counter clockwise.
     1479                class CcwOutArcIt : public Arc {
    14541480      const Graph* _graph;
    14551481      const Node _node;
    14561482    public:
    14571483
    1458       CcwArcIt() { }
     1484      CcwOutArcIt() { }
    14591485
    1460       CcwArcIt(Invalid i) : Arc(i) { }
     1486      CcwOutArcIt(Invalid i) : Arc(i) { }
    14611487
    1462       CcwArcIt(const Graph& graph, const Node& node)
     1488      CcwOutArcIt(const Graph& graph, const Node& node)
    14631489          : _graph(&graph), _node(node) {
    1464         _graph->firstCcw(*this, node);
     1490        _graph->firstOut(*this, node);
    14651491      }
    14661492
    1467       CcwArcIt(const Graph& graph, const Arc& arc)
     1493      CcwOutArcIt(const Graph& graph, const Arc& arc)
    14681494          : Arc(arc), _graph(&graph) {}
    14691495
    1470       CcwArcIt& operator++() {
    1471         _graph->nextCcw(*this, _node);
     1496      CcwOutArcIt& operator++() {
     1497        _graph->nextOut(*this);
    14721498        return *this;
    14731499      }
    14741500
     1501                };
     1502
     1503                /// Iterator class for the outgoing arcs of a node.
     1504
     1505                /// This iterator goes through the outgoing arcs of a node clockwise.
     1506                class CwOutArcIt : public Arc {
     1507      const Graph* _graph;
     1508      const Node _node;
     1509    public:
     1510
     1511      CwOutArcIt() { }
     1512
     1513      CwOutArcIt(Invalid i) : Arc(i) { }
     1514
     1515      CwOutArcIt(const Graph& graph, const Node& node)
     1516          : _graph(&graph), _node(node) {
     1517        _graph->lastOut(*this, node);
     1518      }
     1519
     1520      CwOutArcIt(const Graph& graph, const Arc& arc)
     1521          : Arc(arc), _graph(&graph) {}
     1522
     1523      CwOutArcIt& operator++() {
     1524        _graph->prevOut(*this);
     1525        return *this;
     1526      }
     1527
     1528                };
     1529               
     1530                /// Iterator class for the incoming arcs of a node.
     1531
     1532                /// This iterator goes through the incoming arcs of a node counter clockwise.
     1533                class CcwInArcIt : public Arc {
     1534      const Graph* _graph;
     1535      const Node _node;
     1536    public:
     1537
     1538      CcwInArcIt() { }
     1539
     1540      CcwInArcIt(Invalid i) : Arc(i) { }
     1541
     1542      CcwInArcIt(const Graph& graph, const Node& node)
     1543          : _graph(&graph), _node(node) {
     1544        _graph->firstIn(*this, node);
     1545      }
     1546
     1547      CcwInArcIt(const Graph& graph, const Arc& arc)
     1548          : Arc(arc), _graph(&graph) {}
     1549
     1550      CcwInArcIt& operator++() {
     1551        _graph->nextIn(*this);
     1552        return *this;
     1553      }
     1554
     1555    };
     1556
     1557                /// Iterator class for the incoming arcs of a node.
     1558
     1559                /// This iterator goes through the incoming arcs of a node clockwise.
     1560                class CwInArcIt : public Arc {
     1561      const Graph* _graph;
     1562      const Node _node;
     1563    public:
     1564
     1565      CwInArcIt() { }
     1566
     1567      CwInArcIt(Invalid i) : Arc(i) { }
     1568
     1569      CwInArcIt(const Graph& graph, const Node& node)
     1570          : _graph(&graph), _node(node) {
     1571        _graph->lastIn(*this, node);
     1572      }
     1573
     1574      CwInArcIt(const Graph& graph, const Arc& arc)
     1575          : Arc(arc), _graph(&graph) {}
     1576
     1577      CwInArcIt& operator++() {
     1578        _graph->prevIn(*this);
     1579        return *this;
     1580      }
     1581                       
    14751582    };
    14761583
    14771584    void clear() {
     
    15191626  ///This class provides only linear time counting for nodes, edges, arcs and
    15201627  ///faces.
    15211628  ///
    1522   ///A disconnected planar graph has have an outer face for each of its
     1629  ///A disconnected planar graph has an outer face for each of its
    15231630  ///components, effectively turning them into separate graphs. Each component
    15241631  ///has a corresponding component in the dual.
    15251632  ///\sa concepts::Graph
     
    15371644    /// \brief Constructor
    15381645
    15391646    /// Constructor.
    1540     ///
     1647    /// Creates an empty planar graph.
    15411648    PlanarGraph() {}
    15421649
    1543 
     1650                typedef True PlanarGraphTag;
     1651               
    15441652    ///\brief Constructor that copies a planar embedding
    15451653
    15461654    ///Constructor that copies a planar embedding.
     
    15511659      this->copyEmbedding(g,em,nm,am);
    15521660    }
    15531661
     1662    ///\brief Constructor that copies a planar embedding
     1663
     1664    ///Constructor that copies a planar embedding. Places the mapping from the
     1665                ///nodes and arcs of the old graph to the ones of the new graph into \c nm
     1666                ///and \c am, respectively.
    15541667    template<typename Graph>
    15551668    PlanarGraph(const Graph &g, const lemon::PlanarEmbedding<Graph> &em,
    15561669        typename Graph::template NodeMap<Node> &nm,
     
    15921705      }
    15931706    }
    15941707
    1595     void edge_add_notify(Edge edge) {
     1708    void edgeAddNotify(Edge edge) {
    15961709      notifier(Edge()).add(edge);
    15971710      std::vector<Arc> ev;
    15981711      ev.push_back(Parent::direct(edge, true));
     
    16001713      notifier(Arc()).add(ev);
    16011714    }
    16021715
    1603     void edge_erase_notify(Edge edge) {
     1716    void edgeEraseNotify(Edge edge) {
    16041717      std::vector<Arc> av;
    16051718      av.push_back(Parent::direct(edge, true));
    16061719      av.push_back(Parent::direct(edge, false));
     
    16261739    /// This function adds a new edge to the graph between nodes
    16271740    /// \c u and \c v with inherent orientation from node \c u to
    16281741    /// node \c v. \c p_u and \c p_v are the edges that directly precede the new
    1629     /// edge in anticlockwise order at the nodes \c u and \c v, respectively.
     1742    /// edge in counter clockwise order at the nodes \c u and \c v, respectively.
    16301743    /// INVALID should be passed as \c p_u or \c p_v if and only if the
    16311744    /// respective node is isolated.
    16321745    ///
     
    16591772      if (!valid(f_v) && f_u != f_v) notifier(Face()).erase(f_v);
    16601773      if (!valid(o_u)) notifier(Face()).erase(o_u);
    16611774      if (!valid(o_v)) notifier(Face()).erase(o_v);
    1662       edge_add_notify(edge);
     1775      edgeAddNotify(edge);
    16631776      Face e_l = leftFace(direct(edge,u));
    16641777      Face e_r = rightFace(direct(edge,u));
    16651778      if (e_l != f_u && e_l != f_v && e_l != o_u && e_l != o_v)
     
    17521865      return Parent::valid(f);
    17531866    }
    17541867
    1755     /// \brief Change the first node of an edge.
    1756     ///
    1757     /// Planar graphs don't support changing the endpoints of edges.
    1758     void changeU(Edge e, Node n) = delete;
    1759     /// \brief Change the second node of an edge.
    1760     ///
    1761     /// Planar graphs don't support changing the endpoints of edges.
    1762     void changeV(Edge e, Node n) = delete;
    1763 
    17641868    /// \brief Contract two nodes.
    17651869    ///
    17661870    /// This function contracts the two ends of the given edge.
     
    17861890      if (n1 == n2) return;
    17871891      Node nd;
    17881892      bool simple;
    1789       inner_contract1(n1,n2,nd,simple);
     1893      innerContract1(n1,n2,nd,simple);
    17901894      notifier(Node()).erase(nd);
    1791       edge_erase_notify(e);
    1792       inner_contract2(e,n1,n2,nd,simple);
     1895      edgeEraseNotify(e);
     1896      innerContract2(e,n1,n2,nd,simple);
    17931897    }
    17941898
    17951899    /// \brief Split an edge.
     
    18081912    Node split(Edge e) {
    18091913      Node v;
    18101914      Edge e2;
    1811       inner_split1(v,e2);
     1915      innerSplit1(v,e2);
    18121916      notifier(Node()).add(v);
    1813       edge_add_notify(e2);
    1814       return inner_split2(e,v,e2);
     1917      edgeAddNotify(e2);
     1918      return innerSplit2(e,v,e2);
    18151919    }
    18161920
    18171921    ///Split a node.
    18181922
    18191923    ///This function splits the given node. First, a new node is added
    1820     ///to the graph, then all edges in anticlockwise order from \c e1 until but
     1924    ///to the graph, then all edges in counter clockwise order from \c e1 until but
    18211925    ///not including \c e2
    18221926    ///are re-anchored from \c n to the new node.
    18231927    ///If the second parameter \c connect is \c true (this is the default
     
    18351939    ///Snapshot feature.
    18361940    Node split(Node n1, Edge e1, Edge e2, bool connect) {
    18371941      Node n2;
    1838       inner_split1(n1,n2);
     1942      innerSplit1(n1,n2);
    18391943      notifier(Node()).add(n2);
    18401944      Edge a3;
    1841       inner_split2(n1,n2,e1,e2,connect,a3);
     1945      innerSplit2(n1,n2,e1,e2,connect,a3);
    18421946      if (!connect) {
    18431947        if (a3 != INVALID)
    18441948          erase(a3);
    18451949      } else {
    1846         edge_add_notify(a3);
     1950        edgeAddNotify(a3);
    18471951      }
    18481952      return n2;
    18491953    }
     
    18661970    /// then it is worth reserving space for this amount before starting
    18671971    /// to build the graph.
    18681972    /// \sa reserveEdge()
     1973    /// \sa reserveFace()
    18691974    void reserveNode(int n) {
    18701975      nodes.reserve(n);
    18711976    };
     
    18781983    /// then it is worth reserving space for this amount before starting
    18791984    /// to build the graph.
    18801985    /// \sa reserveNode()
     1986    /// \sa reserveFace()
    18811987    void reserveEdge(int m) {
    18821988      arcs.reserve(2 * m);
    18831989    };
     
    18891995    /// be large (e.g. it will contain millions of nodes and/or edges),
    18901996    /// then it is worth reserving space for this amount before starting
    18911997    /// to build the graph.
    1892     /// \sa reserveFace()
     1998    /// \sa reserveNode()
     1999    /// \sa reserveEdge()
    18932000    void reserveFace(int n) {
    18942001      faces.reserve(n);
    18952002    };
    18962003
     2004  private:
    18972005    class DualBase {
    18982006      const Graph *_graph;
    18992007    protected:
     
    19392047      void next(Node &i) const {
    19402048        _graph->next(i);
    19412049      }
     2050      void first(Edge &i) const {
     2051        _graph->first(i);
     2052      }
     2053      void next(Edge &i) const {
     2054        _graph->next(i);
     2055      }
    19422056      void first(Arc &i) const {
    19432057        _graph->first(i);
    19442058      }
    19452059      void next(Arc &i) const {
    19462060        _graph->next(i);
    19472061      }
     2062      void firstInc(Edge& i, bool &dir, const Node& n) const {
     2063                          Arc e;
     2064        _graph->lastInF(e, n);
     2065                                i = e;
     2066                                dir = _graph->direction(e);
     2067      }
     2068      void nextInc(Edge& i, bool &dir) const {
     2069                          Arc e = _graph->direct(i, dir);
     2070        _graph->prevInF(e);
     2071                                i = e;
     2072                                dir = _graph->direction(e);
     2073      }
    19482074      void firstCcw(Arc& i, const Node& n) const {
    19492075        _graph->lastInF(i, n);
    19502076      }
     
    19572083      void nextIn(Arc& i) const {
    19582084        _graph->nextInF(i);
    19592085      }
     2086      void lastIn(Arc& i, const Node& n) const {
     2087        _graph->lastInF(i, n);
     2088      }
     2089      void prevIn(Arc& i) const {
     2090        _graph->prevInF(i);
     2091      }
    19602092      void firstCwF(Arc& i, const Face& n) const {
    1961         _graph->lastIn(i, n);
     2093        _graph->lastOut(i, n);
    19622094      }
    19632095      void nextCwF(Arc& i) const {
    1964         _graph->prevIn(i);
     2096        _graph->prevOut(i);
     2097      }
     2098      void firstCcwF(Arc& i, const Face& n) const {
     2099        _graph->firstOut(i, n);
     2100      }
     2101      void nextCcwF(Arc& i) const {
     2102        _graph->nextOut(i);
    19652103      }
    19662104      void firstOut(Arc& i, const Node& n ) const {
    1967         _graph->firstOutF(i, n);
     2105        _graph->firstCcwF(i, n);
    19682106      }
    19692107      void nextOut(Arc& i) const {
    1970         _graph->nextOutF(i);
     2108        _graph->nextCcwF(i);
     2109      }
     2110      void lastOut(Arc& i, const Node& n ) const {
     2111        _graph->firstCwF(i, n);
     2112      }
     2113      void prevOut(Arc& i) const {
     2114        _graph->nextCwF(i);
    19712115      }
    19722116      void first(Face &i) const {
    19732117        _graph->first(i);
     
    20042148      bool valid(Face n) const {
    20052149        return _graph->valid(n);
    20062150      }
    2007 
     2151                        Node u(Edge e) const {
     2152                                return _graph->w1(e);
     2153                        }
     2154                        Node v(Edge e) const {
     2155                                return _graph->w2(e);
     2156                        }
     2157                        Face w1(Edge e) const {
     2158                                return _graph->u(e);
     2159                        }
     2160                        Face w2(Edge e) const {
     2161                                return _graph->v(e);
     2162                        }
     2163                       
    20082164    };
    20092165
    20102166    typedef PlanarGraphExtender<GraphExtender<DualBase> > ExtendedDualBase;
    20112167
    2012   /// Adaptor class for the dual of a planar graph.
     2168        public:         
    20132169
    2014   /// This is an adaptor class for the dual of a planar graph.
    2015   class Dual : public ExtendedDualBase {
    2016     public:
     2170                /// Adaptor class for the dual of a planar graph.
     2171
     2172                /// This is an adaptor class for the dual of a planar graph.
     2173                /// Nodes in the dual graph correspond to the faces of the underlying planar
     2174                /// graph and vice versa. For this reason, the type Node in Dual is the same
     2175                /// as Face in PlanarGraph and vice versa. All the iterators, maps and
     2176                /// inspector functions work the same way as with PlanarGraph.
     2177                class Dual : public ExtendedDualBase {
     2178                public:
    20172179      Dual(const PlanarGraph &graph) {
    20182180        initialize(&graph);
    20192181      }
  • lemon/plane_graph.h

    diff -r 10d57978f900 -r 2c0edf00dc8f lemon/plane_graph.h
    a b  
    2121
    2222///\ingroup graphs
    2323///\file
    24 ///\brief PlaneGraph classes. UNDER CONSTRUCTION.
     24///\brief PlaneGraph class.
    2525
    2626#include <lemon/planarity.h>
    2727#include <lemon/planar_graph.h>
     
    457457  ///\ref PlaneGraph adds geometry features to PlanarGraph. While PlanarGraph
    458458  ///must be built from the topology, PlaneGraph requires coordinates for nodes
    459459  ///and determines the topology that fits the coordinates.
     460        ///This class takes an edge shape type as a template parameter. The following
     461        ///classes can be used as an edge shape type:
     462        /// - PlaneGraphStraightEdge
     463        /// - PlaneGraphLineStripEdge
     464        /// - PlaneGraphBezier2Edge
     465        /// - PlaneGraphBezier3Edge
     466        ///A custom edge shape must have the following:
     467        /// - typedef Point; - a point type, such as dim2::Point
     468        /// - typedef Shape; - type which stores the shape data
     469        /// - static Shape create(); - creates an "empty" shape
     470        /// - static Shape create(...); - creates a shape with arbitrary data
     471        /// - static Point source(Shape); - returns the source point of an edge
     472        /// - static Point target(Shape); - returns the target point of an edge
     473        /// - static Shape reverse(Shape); - reverses an edge
     474        /// - static bool between(Shape c, Shape a, Shape b); - returns true if and
     475        ///     only if c should go between a and b in counter clockwise order
     476        /// - static bool intersect(Shape, Shape); - checks if two edges intersect
     477        /// - static bool degenerate(Shape); - checks if a shape is invalid
    460478  ///\sa PlanarGraph
    461479  template <typename EdgeType = PlaneGraphStraightEdge>
    462480  class PlaneGraph : public PlanarGraph {
     
    522540        }
    523541    }
    524542
     543    ///\brief Constructor that copies a planar drawing
     544
     545    ///Constructor that copies a planar drawing. Places the mapping from the
     546                ///nodes and arcs of the old graph to the ones of the new graph into \c nm
     547                ///and \c em, respectively.
    525548    template<typename Graph>
    526549    PlaneGraph(const Graph &graph, const lemon::PlanarDrawing<Graph> &drawing,
    527550        typename Graph::template NodeMap<Node> &nm,
     
    633656      if (p_v != INVALID && (p_u == INVALID || leftFace(p_u) != leftFace(p_v))
    634657        && checkIntersections(es,p_v)) return INVALID;
    635658
    636 #ifdef REMOVE_BEFORE_RELEASE
    637             std::cout << "AddArc: " << id(n1) << "->" << id(n2) << ", p_u: "
    638              << id(p_u) << ", p_v: " << id(p_v) << std::endl;
    639 #endif
    640659      Edge e = PlanarGraph::addEdge(n1,n2,p_u,p_v);
    641660      if (e != INVALID) {
    642661        if (n1 != n2 || EdgeType::between(esr,edgeshapes[p_u],es)) {
     
    667686    }
    668687
    669688    ///Get a map of the node locations.
     689               
    670690    ///Get a map of the node locations.
     691                ///
    671692    const NodeMap<EdgePoint> &nodePosMap() const {
    672693      return nodepos;
    673694    }
    674695
    675696    ///Tell the location of a node.
     697               
    676698    ///Tell the location of a node.
     699                ///
    677700    const EdgePoint &locate(const Node &n) const {
    678701      return nodepos[n];
    679702    }
    680703
    681704    ///Tell the location of an arc.
     705               
    682706    ///Tell the location of an arc.
     707                ///
    683708    const EdgeShape &locate(const Arc &a) const {
    684709      return edgeshapes[a];
    685710    }
     
    693718
    694719    /// Iterator class for the edge shapes around a node.
    695720
    696     /// This iterator goes through the arcs around a node anticlockwise.
     721    /// This iterator goes through the arcs around a node counter clockwise.
     722                ///
    697723    class CcwIncIt : public Arc {
    698724      const PlaneGraph* _graph;
    699725      const Node _node;
     
    725751    /// Iterator class for the edge shapes around a node.
    726752
    727753    /// This iterator goes through the arcs around a node clockwise.
     754                ///
    728755    class CwIncIt : public Arc {
    729756      const PlaneGraph* _graph;
    730757      const Node _node;
     
    756783    /// Iterator class for the edge shapes on the boundary of a face.
    757784
    758785    /// This iterator goes through the arcs on the boundary of a face clockwise.
     786                ///
    759787    class CwBoundaryIt {
    760788      const PlaneGraph* _graph;
    761789      Face _face;
     
    786814    /// Iterator class for the edge shapes on the boundary of a face.
    787815
    788816    /// This iterator goes through the arcs on the boundary of a face
    789     /// anticlockwise.
     817    /// counter clockwise.
    790818    class CcwBoundaryIt {
    791819      const PlaneGraph* _graph;
    792820      Face _face;
  • test/planar_graph_test.cc

    diff -r 10d57978f900 -r 2c0edf00dc8f test/planar_graph_test.cc
    a b  
    9191}
    9292
    9393template <class Graph>
     94void checkGraphDual() {
     95  TEMPLATE_GRAPH_TYPEDEFS(Graph);
     96
     97  Graph G;
     98  Node n1 = G.addNode(),
     99       n2 = G.addNode(),
     100       n3 = G.addNode(),
     101       n4 = G.addNode();
     102  Edge e1 = G.addEdge(n1, n2, INVALID, INVALID),
     103       e2 = G.addEdge(n1, n3, e1, INVALID),
     104       e3 = G.addEdge(n1, n4, e2, INVALID),
     105       e4 = G.addEdge(n2, n3, e1, e2),
     106       e5 = G.addEdge(n4, n3, e3, e4);
     107                         
     108        typedef PlanarGraph::Dual PD;
     109        PD D(G);
     110        checkGraphNodeList(D, 3);
     111        checkGraphEdgeList(D, 5);
     112        checkGraphArcList(D, 10);
     113        checkGraphFaceList(D, 4);
     114
     115  checkGraphIncEdgeArcLists(D, G.leftFace(G.direct(e3, false)), 3);
     116  checkGraphIncEdgeArcLists(D, G.leftFace(G.direct(e3, true)), 4);
     117  checkGraphIncEdgeArcLists(D, G.leftFace(G.direct(e2, false)), 3);
     118  checkGraphBoundaryArcList(D, n1, 3);
     119  checkGraphBoundaryArcList(D, n2, 2);
     120  checkGraphBoundaryArcList(D, n3, 3);
     121  checkGraphBoundaryArcList(D, n4, 2);
     122       
     123}
     124
     125template <class Graph>
    94126void checkPlaneGraphBuild() {
    95127  TEMPLATE_GRAPH_TYPEDEFS(Graph);
    96128
     
    154186  checkGraphFaceMap(G);
    155187}
    156188
     189PlaneGraphLineStripEdge::Shape p2e(dim2::Point<double> p1,
     190        dim2::Point<double> p2) {
     191        std::vector<dim2::Point<double> > v(2);
     192        v[0] = p1;
     193        v[1] = p2;
     194        return PlaneGraphLineStripEdge::create(v);
     195}
     196
     197template<class Graph>
     198void checkPlaneGraph2Build() {
     199  TEMPLATE_GRAPH_TYPEDEFS(Graph);
     200       
     201        Graph G;
     202        typedef dim2::Point<double> Pt;
     203  Node
     204    n1 = G.addNode(Pt(0.0,1.0)),
     205    n2 = G.addNode(Pt(0.0,0.0)),
     206    n3 = G.addNode(Pt(1.0,0.0)),
     207    n4 = G.addNode(Pt(1.0,1.0)),
     208    n5 = G.addNode(Pt(2.0,0.5));
     209        Edge
     210          e1 = G.addEdge(p2e(Pt(0.0,1.0), Pt(0.0,0.0))),
     211          e2 = G.addEdge(p2e(Pt(0.0,1.0), Pt(1.0,0.0))),
     212          e3 = G.addEdge(p2e(Pt(0.0,1.0), Pt(1.0,1.0))),
     213          e4 = G.addEdge(p2e(Pt(0.0,0.0), Pt(1.0,0.0))),
     214          e5 = G.addEdge(p2e(Pt(1.0,1.0), Pt(1.0,0.0))),
     215          e6 = G.addEdge(p2e(Pt(0.0,1.0), Pt(1.0,1.0))),        //invalid
     216          e7 = G.addEdge(p2e(Pt(0.0,1.0), Pt(2.0,0.5)));        //invalid
     217
     218                checkGraphNodeList(G, 5);
     219                checkGraphEdgeList(G, 5);
     220                checkGraphArcList(G, 10);
     221                checkGraphFaceList(G, 4);
     222
     223                checkGraphIncEdgeArcLists(G, n1, 3);
     224                checkGraphIncEdgeArcLists(G, n2, 2);
     225                checkGraphIncEdgeArcLists(G, n3, 3);
     226                checkGraphIncEdgeArcLists(G, n4, 2);
     227                checkGraphIncEdgeArcLists(G, n5, 0);
     228               
     229        }
     230
     231PlaneGraphBezier2Edge::Shape p3e(dim2::Point<double> p1,
     232        dim2::Point<double> p2, dim2::Point<double> p3) {
     233        return PlaneGraphBezier2Edge::create(p1, p2, p3);
     234}
     235
     236template<class Graph>
     237void checkPlaneGraph3Build() {
     238  TEMPLATE_GRAPH_TYPEDEFS(Graph);
     239       
     240        Graph G;
     241        typedef dim2::Point<double> Pt;
     242  Node
     243    n1 = G.addNode(Pt(0.0,1.0)),
     244    n2 = G.addNode(Pt(0.0,0.0)),
     245    n3 = G.addNode(Pt(1.0,0.0)),
     246    n4 = G.addNode(Pt(1.0,1.0)),
     247    n5 = G.addNode(Pt(2.0,0.5));
     248        Edge
     249          e1 = G.addEdge(p3e(Pt(0.0,1.0), Pt(-1.0,0.5), Pt(0.0,0.0))),
     250          e2 = G.addEdge(p3e(Pt(0.0,1.0), Pt(0.6,0.6), Pt(1.0,0.0))),
     251          e3 = G.addEdge(p3e(Pt(0.0,1.0), Pt(0.5,1.1), Pt(1.0,1.0))),
     252          e4 = G.addEdge(p3e(Pt(0.0,0.0), Pt(0.5,-0.1), Pt(1.0,0.0))),
     253          e5 = G.addEdge(p3e(Pt(1.0,1.0), Pt(1.1,0.5),  Pt(1.0,0.0))),
     254          e6 = G.addEdge(p3e(Pt(0.0,1.0), Pt(0.6,0.6), Pt(1.0,1.0))),   //invalid
     255          e7 = G.addEdge(p3e(Pt(0.0,1.0), Pt(1.6,0.75), Pt(2.0,0.5)));  //invalid
     256
     257                checkGraphNodeList(G, 5);
     258                checkGraphEdgeList(G, 5);
     259                checkGraphArcList(G, 10);
     260                checkGraphFaceList(G, 4);
     261
     262                checkGraphIncEdgeArcLists(G, n1, 3);
     263                checkGraphIncEdgeArcLists(G, n2, 2);
     264                checkGraphIncEdgeArcLists(G, n3, 3);
     265                checkGraphIncEdgeArcLists(G, n4, 2);
     266                checkGraphIncEdgeArcLists(G, n5, 0);
     267               
     268        }
     269
     270PlaneGraphBezier3Edge::Shape p4e(dim2::Point<double> p1,
     271        dim2::Point<double> p2, dim2::Point<double> p3, dim2::Point<double> p4) {
     272        return PlaneGraphBezier3Edge::create(p1, p2, p3, p4);
     273}
     274
     275template<class Graph>
     276void checkPlaneGraph4Build() {
     277  TEMPLATE_GRAPH_TYPEDEFS(Graph);
     278       
     279        Graph G;
     280        typedef dim2::Point<double> Pt;
     281  Node
     282    n1 = G.addNode(Pt(0.0,1.0)),
     283    n2 = G.addNode(Pt(0.0,0.0)),
     284    n3 = G.addNode(Pt(1.0,0.0)),
     285    n4 = G.addNode(Pt(1.0,1.0)),
     286    n5 = G.addNode(Pt(2.0,0.5));
     287        Edge
     288          e1 = G.addEdge(p4e(Pt(0.0,1.0), Pt(-0.1,0.66), Pt(-0.1,0.33), Pt(0.0,0.0))),
     289          e2 = G.addEdge(p4e(Pt(0.0,1.0), Pt(0.33,0.33), Pt(0.66,0.66), Pt(1.0,0.0))),
     290          e3 = G.addEdge(p4e(Pt(0.0,1.0), Pt(0.33,1.1), Pt(0.66,1.1), Pt(1.0,1.0))),
     291          e4 = G.addEdge(p4e(Pt(0.0,0.0), Pt(0.33,-0.1), Pt(0.66,-0.1), Pt(1.0,0.0))),
     292          e5 = G.addEdge(p4e(Pt(1.0,1.0), Pt(1.1,0.66), Pt(1.1,0.33), Pt(1.0,0.0))),
     293          e6 = G.addEdge(p4e(Pt(0.0,1.0), Pt(0.33,0.33), Pt(0.66,0.66), Pt(1.0,1.0))),
     294          e7 = G.addEdge(p4e(Pt(0.0,1.0), Pt(1.0,0.75), Pt(1.5,0.66), Pt(2.0,0.5)));
     295
     296                checkGraphNodeList(G, 5);
     297                checkGraphEdgeList(G, 5);
     298                checkGraphArcList(G, 10);
     299                checkGraphFaceList(G, 4);
     300
     301                checkGraphIncEdgeArcLists(G, n1, 3);
     302                checkGraphIncEdgeArcLists(G, n2, 2);
     303                checkGraphIncEdgeArcLists(G, n3, 3);
     304                checkGraphIncEdgeArcLists(G, n4, 2);
     305                checkGraphIncEdgeArcLists(G, n5, 0);
     306               
     307        }
     308
    157309template <class Graph>
    158310void checkGraphArcSplit() {
    159311  TEMPLATE_GRAPH_TYPEDEFS(Graph);
     
    493645void checkGraphs() {
    494646  { // Checking PlanarGraph
    495647    checkGraphBuild<PlanarGraph>();
     648    checkGraphDual<PlanarGraph>();
    496649    checkPlaneGraphBuild<PlaneGraph<> >();
     650    checkPlaneGraph2Build<PlaneGraph<PlaneGraphLineStripEdge> >();
     651    checkPlaneGraph3Build<PlaneGraph<PlaneGraphBezier2Edge> >();
     652    checkPlaneGraph4Build<PlaneGraph<PlaneGraphBezier3Edge> >();
    497653    checkGraphArcSplit<PlanarGraph>();
    498654    checkGraphNodeSplit<PlanarGraph>();
    499655    checkGraphContract<PlanarGraph>();
  • test/planar_graph_test.h

    diff -r 10d57978f900 -r 2c0edf00dc8f test/planar_graph_test.h
    a b  
    1616 *
    1717 */
    1818
    19 #ifndef LEMON_TEST_GRAPH_TEST_H
    20 #define LEMON_TEST_GRAPH_TEST_H
     19#ifndef LEMON_TEST_PLANAR_GRAPH_TEST_H
     20#define LEMON_TEST_PLANAR_GRAPH_TEST_H
    2121
    2222#include <set>
    2323
     
    2525#include <lemon/maps.h>
    2626
    2727#include "test_tools.h"
     28#include "graph_test.h"
    2829
    2930namespace lemon {
    3031
    3132  template<class Graph>
    32   void checkGraphNodeList(const Graph &G, int cnt)
    33   {
    34     typename Graph::NodeIt n(G);
    35     for(int i=0;i<cnt;i++) {
    36       check(n!=INVALID,"Wrong Node list linking.");
    37       ++n;
    38     }
    39     check(n==INVALID,"Wrong Node list linking.");
    40     check(countNodes(G)==cnt,"Wrong Node number.");
    41   }
    42 
    43   template<class Graph>
    4433  void checkGraphFaceList(const Graph &G, int cnt)
    4534  {
    4635    typename Graph::FaceIt n(G);
     
    5342  }
    5443
    5544  template<class Graph>
    56   void checkGraphArcList(const Graph &G, int cnt)
    57   {
    58     typename Graph::ArcIt e(G);
    59     for(int i=0;i<cnt;i++) {
    60       check(e!=INVALID,"Wrong Arc list linking.");
    61       check(G.oppositeNode(G.source(e), e) == G.target(e),
    62             "Wrong opposite node");
    63       check(G.oppositeNode(G.target(e), e) == G.source(e),
    64             "Wrong opposite node");
    65       ++e;
    66     }
    67     check(e==INVALID,"Wrong Arc list linking.");
    68     check(countArcs(G)==cnt,"Wrong Arc number.");
    69   }
    70 
    71   template<class Graph>
    72   void checkGraphOutArcList(const Graph &G, typename Graph::Node n, int cnt)
    73   {
    74     typename Graph::OutArcIt e(G,n);
    75     for(int i=0;i<cnt;i++) {
    76       check(e!=INVALID,"Wrong OutArc list linking.");
    77       check(n==G.source(e),"Wrong OutArc list linking.");
    78       check(n==G.baseNode(e),"Wrong OutArc list linking.");
    79       check(G.target(e)==G.runningNode(e),"Wrong OutArc list linking.");
    80       ++e;
    81     }
    82     check(e==INVALID,"Wrong OutArc list linking.");
    83     check(countOutArcs(G,n)==cnt,"Wrong OutArc number.");
    84   }
    85 
    86   template<class Graph>
    87   void checkGraphInArcList(const Graph &G, typename Graph::Node n, int cnt)
    88   {
    89     typename Graph::InArcIt e(G,n);
    90     for(int i=0;i<cnt;i++) {
    91       check(e!=INVALID,"Wrong InArc list linking.");
    92       check(n==G.target(e),"Wrong InArc list linking.");
    93       check(n==G.baseNode(e),"Wrong OutArc list linking.");
    94       check(G.source(e)==G.runningNode(e),"Wrong OutArc list linking.");
    95       ++e;
    96     }
    97     check(e==INVALID,"Wrong InArc list linking.");
    98     check(countInArcs(G,n)==cnt,"Wrong InArc number.");
    99   }
    100 
    101   template<class Graph>
    102   void checkGraphEdgeList(const Graph &G, int cnt)
    103   {
    104     typename Graph::EdgeIt e(G);
    105     for(int i=0;i<cnt;i++) {
    106       check(e!=INVALID,"Wrong Edge list linking.");
    107       check(G.oppositeNode(G.u(e), e) == G.v(e), "Wrong opposite node");
    108       check(G.oppositeNode(G.v(e), e) == G.u(e), "Wrong opposite node");
    109       ++e;
    110     }
    111     check(e==INVALID,"Wrong Edge list linking.");
    112     check(countEdges(G)==cnt,"Wrong Edge number.");
    113   }
    114 
    115   template<class Graph>
    116   void checkGraphIncEdgeList(const Graph &G, typename Graph::Node n, int cnt)
    117   {
    118     typename Graph::IncEdgeIt e(G,n);
    119     for(int i=0;i<cnt;i++) {
    120       check(e!=INVALID,"Wrong IncEdge list linking.");
    121       check(n==G.u(e) || n==G.v(e),"Wrong IncEdge list linking.");
    122       check(n==G.baseNode(e),"Wrong OutArc list linking.");
    123       check(G.u(e)==G.runningNode(e) || G.v(e)==G.runningNode(e),
    124             "Wrong OutArc list linking.");
    125       ++e;
    126     }
    127     check(e==INVALID,"Wrong IncEdge list linking.");
    128     check(countIncEdges(G,n)==cnt,"Wrong IncEdge number.");
    129   }
    130 
    131   template <class Graph>
    132   void checkGraphIncEdgeArcLists(const Graph &G, typename Graph::Node n,
    133                                  int cnt)
    134   {
    135     checkGraphIncEdgeList(G, n, cnt);
    136     checkGraphOutArcList(G, n, cnt);
    137     checkGraphInArcList(G, n, cnt);
    138   }
    139 
    140   template<class Graph>
    14145  void checkGraphBoundaryArcList(const Graph &G, typename Graph::Face n, int
    14246    cnt)
    14347  {
    144     typename Graph::CwBoundaryArcIt e(G,n);
     48    typename Graph::CwBoundaryArcIt e1(G,n);
     49    typename Graph::CcwBoundaryArcIt e2(G,n);
     50                std::vector<int> v(cnt);
    14551    for(int i=0;i<cnt;i++) {
    146       check(e!=INVALID,"Wrong CwBoundaryArc list linking.");
    147       check(n==G.w1(e) || n==G.w2(e),"Wrong CwBoundaryArc list linking.");
    148       ++e;
     52      check(e1!=INVALID,"Wrong CwBoundaryArc list linking.");
     53      check(n==G.w1(e1) || n==G.w2(e1),"Wrong CwBoundaryArc list linking.");
     54                        v[i] = G.id(e1);
     55      ++e1;
    14956    }
    150     check(e==INVALID,"Wrong BoundaryArc list linking.");
    151     check(countBoundaryArcs(G,n)==cnt,"Wrong IncEdge number.");
    152   }
    153 
    154   template <class Graph>
    155   void checkGraphConArcList(const Graph &G, int cnt) {
    156     int i = 0;
    157     for (typename Graph::NodeIt u(G); u != INVALID; ++u) {
    158       for (typename Graph::NodeIt v(G); v != INVALID; ++v) {
    159         for (ConArcIt<Graph> a(G, u, v); a != INVALID; ++a) {
    160           check(G.source(a) == u, "Wrong iterator.");
    161           check(G.target(a) == v, "Wrong iterator.");
    162           ++i;
    163         }
    164       }
     57    check(e1==INVALID,"Wrong BoundaryArc list linking.");
     58    for(int i=0;i<cnt;i++) {
     59      check(e2!=INVALID,"Wrong CcwBoundaryArc list linking.");
     60      check(n==G.w1(e2) || n==G.w2(e2),"Wrong CcwBoundaryArc list linking.");
     61                        check(v[cnt-1-i] == G.id(e2),"Conflicting Cw and Ccw iterators.");
     62      ++e2;
    16563    }
    166     check(cnt == i, "Wrong iterator.");
    167   }
    168 
    169   template <class Graph>
    170   void checkGraphConEdgeList(const Graph &G, int cnt) {
    171     int i = 0;
    172     for (typename Graph::NodeIt u(G); u != INVALID; ++u) {
    173       for (typename Graph::NodeIt v(G); v != INVALID; ++v) {
    174         for (ConEdgeIt<Graph> e(G, u, v); e != INVALID; ++e) {
    175           check((G.u(e) == u && G.v(e) == v) ||
    176                 (G.u(e) == v && G.v(e) == u), "Wrong iterator.");
    177           i += u == v ? 2 : 1;
    178         }
    179       }
    180     }
    181     check(2 * cnt == i, "Wrong iterator.");
     64    check(e2==INVALID,"Wrong BoundaryArc list linking.");
     65    check(countBoundaryArcs(G,n)==cnt,"Wrong Boundary Arc number.");
    18266  }
    18367
    18468  template<class Graph>
     
    20690  }
    20791
    20892  template <typename Graph>
    209   void checkArcDirections(const Graph& G) {
    210     for (typename Graph::ArcIt a(G); a != INVALID; ++a) {
    211       check(G.source(a) == G.target(G.oppositeArc(a)), "Wrong direction");
    212       check(G.target(a) == G.source(G.oppositeArc(a)), "Wrong direction");
    213       check(G.direct(a, G.direction(a)) == a, "Wrong direction");
    214     }
    215   }
    216 
    217   template <typename Graph>
    218   void checkNodeIds(const Graph& G) {
    219     std::set<int> values;
    220     for (typename Graph::NodeIt n(G); n != INVALID; ++n) {
    221       check(G.nodeFromId(G.id(n)) == n, "Wrong id");
    222       check(values.find(G.id(n)) == values.end(), "Wrong id");
    223       check(G.id(n) <= G.maxNodeId(), "Wrong maximum id");
    224       values.insert(G.id(n));
    225     }
    226   }
    227 
    228   template <typename Graph>
    229   void checkArcIds(const Graph& G) {
    230     std::set<int> values;
    231     for (typename Graph::ArcIt a(G); a != INVALID; ++a) {
    232       check(G.arcFromId(G.id(a)) == a, "Wrong id");
    233       check(values.find(G.id(a)) == values.end(), "Wrong id");
    234       check(G.id(a) <= G.maxArcId(), "Wrong maximum id");
    235       values.insert(G.id(a));
    236     }
    237   }
    238 
    239   template <typename Graph>
    240   void checkEdgeIds(const Graph& G) {
    241     std::set<int> values;
    242     for (typename Graph::EdgeIt e(G); e != INVALID; ++e) {
    243       check(G.edgeFromId(G.id(e)) == e, "Wrong id");
    244       check(values.find(G.id(e)) == values.end(), "Wrong id");
    245       check(G.id(e) <= G.maxEdgeId(), "Wrong maximum id");
    246       values.insert(G.id(e));
    247     }
    248   }
    249 
    250   template <typename Graph>
    25193  void checkFaceIds(const Graph& G) {
    25294    std::set<int> values;
    25395    for (typename Graph::FaceIt n(G); n != INVALID; ++n) {
     
    259101  }
    260102
    261103  template <typename Graph>
    262   void checkGraphNodeMap(const Graph& G) {
    263     typedef typename Graph::Node Node;
    264     typedef typename Graph::NodeIt NodeIt;
    265 
    266     typedef typename Graph::template NodeMap<int> IntNodeMap;
    267     IntNodeMap map(G, 42);
    268     for (NodeIt it(G); it != INVALID; ++it) {
    269       check(map[it] == 42, "Wrong map constructor.");
    270     }
    271     int s = 0;
    272     for (NodeIt it(G); it != INVALID; ++it) {
    273       map[it] = 0;
    274       check(map[it] == 0, "Wrong operator[].");
    275       map.set(it, s);
    276       check(map[it] == s, "Wrong set.");
    277       ++s;
    278     }
    279     s = s * (s - 1) / 2;
    280     for (NodeIt it(G); it != INVALID; ++it) {
    281       s -= map[it];
    282     }
    283     check(s == 0, "Wrong sum.");
    284 
    285     // map = constMap<Node>(12);
    286     // for (NodeIt it(G); it != INVALID; ++it) {
    287     //   check(map[it] == 12, "Wrong operator[].");
    288     // }
    289   }
    290 
    291   template <typename Graph>
    292   void checkGraphArcMap(const Graph& G) {
    293     typedef typename Graph::Arc Arc;
    294     typedef typename Graph::ArcIt ArcIt;
    295 
    296     typedef typename Graph::template ArcMap<int> IntArcMap;
    297     IntArcMap map(G, 42);
    298     for (ArcIt it(G); it != INVALID; ++it) {
    299       check(map[it] == 42, "Wrong map constructor.");
    300     }
    301     int s = 0;
    302     for (ArcIt it(G); it != INVALID; ++it) {
    303       map[it] = 0;
    304       check(map[it] == 0, "Wrong operator[].");
    305       map.set(it, s);
    306       check(map[it] == s, "Wrong set.");
    307       ++s;
    308     }
    309     s = s * (s - 1) / 2;
    310     for (ArcIt it(G); it != INVALID; ++it) {
    311       s -= map[it];
    312     }
    313     check(s == 0, "Wrong sum.");
    314 
    315     // map = constMap<Arc>(12);
    316     // for (ArcIt it(G); it != INVALID; ++it) {
    317     //   check(map[it] == 12, "Wrong operator[].");
    318     // }
    319   }
    320 
    321   template <typename Graph>
    322   void checkGraphEdgeMap(const Graph& G) {
    323     typedef typename Graph::Edge Edge;
    324     typedef typename Graph::EdgeIt EdgeIt;
    325 
    326     typedef typename Graph::template EdgeMap<int> IntEdgeMap;
    327     IntEdgeMap map(G, 42);
    328     for (EdgeIt it(G); it != INVALID; ++it) {
    329       check(map[it] == 42, "Wrong map constructor.");
    330     }
    331     int s = 0;
    332     for (EdgeIt it(G); it != INVALID; ++it) {
    333       map[it] = 0;
    334       check(map[it] == 0, "Wrong operator[].");
    335       map.set(it, s);
    336       check(map[it] == s, "Wrong set.");
    337       ++s;
    338     }
    339     s = s * (s - 1) / 2;
    340     for (EdgeIt it(G); it != INVALID; ++it) {
    341       s -= map[it];
    342     }
    343     check(s == 0, "Wrong sum.");
    344 
    345     // map = constMap<Edge>(12);
    346     // for (EdgeIt it(G); it != INVALID; ++it) {
    347     //   check(map[it] == 12, "Wrong operator[].");
    348     // }
    349   }
    350 
    351 
    352   template <typename Graph>
    353104  void checkGraphFaceMap(const Graph& G) {
    354105    typedef typename Graph::Face Face;
    355106    typedef typename Graph::FaceIt FaceIt;