Esempio n. 1
0
/*
 * Embeds all edges in path P' from t1 to t2 and all back-edges with
 * representant in P' (emb_list).
 * emb_back_edges_out_w is false only in case of 2 terminal
 * nodes, for one of the two terminals (see calculate_partial_embedding).
 * Returns an ordered list of all representants to be embedded later
 * (see add_old_cnode_to_embedding).
 * Precondition:
 * - if u is a node in P' and e is a back-edge with representant u then e is in list
 *   b_edges_repres[u].
 */
list<node> PlanarityTestImpl::embedUpwardT(bool embBackEdgesOutW,
    node t1,
    node t2,
    Graph *sG,
    node w,
    map<node , list<edge> > &bEdgesRepres,
    list<node>& traversedNodes,
    tlp::BmdList<edge>& embList) {
  list<node> toEmbedLater;
  node u = t1, predU = NULL_NODE;

  while (predU != t2) {
    if (isCNode(u)) {
      node f = predU,
           oldCNode = activeCNodeOf(false, u);
      addOldCNodeToEmbedding(embBackEdgesOutW, sG, w, oldCNode, f,
                             bEdgesRepres, traversedNodes, toEmbedLater,
                             embList);
      u = parent.get(oldCNode.id);

      if (u == t2)
        return toEmbedLater;
    }
    else {
      if (predU != NULL_NODE) {

        embList.push(edgeReversal( T0EdgeIn.get(predU.id)));

        if (u != w)
          embList.push(T0EdgeIn.get(predU.id));
        else
          embList.append(T0EdgeIn.get(predU.id));
      }
    }

    if (hasBackEdge.get(u.id) && u != t2)
      embedBackEdges(embBackEdgesOutW, sG, u, traversedNodes,
                     bEdgesRepres[u], embList);

    predU = u;
    u = parent.get(u.id);
  }

  return toEmbedLater;
}
Esempio n. 2
0
//=================================================================
void PlanarityTestImpl::calcNewRBCFromTerminalNode(node newCNode,
    node n,
    node n1,
    node n2,
    tlp::BmdList<node>& nodeList) {
  node t = n1;
  node predT = NULL_NODE;
  node parentT = NULL_NODE;

  while (t != n2) {
    parentT = parent.get(t.id);

    //    cout << "Tulip t =  " << t.id << "  : ";
    if (isCNode(t)) {
      //      cout << "Is CNode" << endl;
      t = activeCNodeOf(false, t);
      addOldCNodeRBCToNewRBC(t, newCNode, n, predT, NULL_NODE, nodeList);
      parentT = parent.get(t.id);
      parent.set(t.id, newCNode);

      if (labelB.get(t.id) > labelB.get(newCNode.id)) {
        labelB.set(newCNode.id, labelB.get(t.id));

        if (embed) // needed to calculate obstruction edges;
          nodeLabelB.set(newCNode.id, nodeLabelB.get(t.id));
      }
    }
    else {
      //      cout << "Not Is CNode :" << t << endl;
      parent.set(t.id, newCNode);
      updateLabelB(t);

      if (labelB.get(t.id) > dfsPosNum.get(n.id)) {
        BmdLink<node>* item = nodeList.append(t);
        ptrItem.set(t.id, item) ;//nodeList.append(t));
      }

      if (labelB.get(t.id) > labelB.get(newCNode.id)) {
        labelB.set(newCNode.id, labelB.get(t.id));

        if (embed) // needed to calculate obstruction edges;
          nodeLabelB.set(newCNode.id, nodeLabelB.get(t.id));
      }
    }

    if (!isCNode(t))
      predT = t; // predT is never a c-node;

    t = parentT;
  }
}
Esempio n. 3
0
//=================================================================
void PlanarityTestImpl::addOldCNodeRBCToNewRBC(node oldCNode, node, node n, node n1, node n2,
                                               tlp::BmdList<node> &nodeList) {
  // compress RBC[oldCNode]:
  // removes all nodes v in RBC[oldCNode] s.t. label_b[v] < dfspos_num[n]
  // or v = parent[oldCNode].

  BmdLink<node> *firstItem = RBC[oldCNode].firstItem();
  BmdLink<node> *predItem = RBC[oldCNode].cyclicPred(firstItem, nullptr);
  BmdLink<node> *succItem = RBC[oldCNode].cyclicSucc(firstItem, nullptr);

  node predNode = predItem->getData();
  node succNode = succItem->getData();
  node ul;
  node ur;

  // goes to the left;
  while (labelB.get(predNode.id) == dfsPosNum.get(n.id) && predNode != n1 && predNode != n2) {
    if (!ul.isValid())
      ul = predNode;

    BmdLink<node> *tmp = predItem;
    predItem = RBC[oldCNode].cyclicPred(predItem, firstItem);
    predNode = predItem->getData();
    RBC[oldCNode].delItem(tmp);
  }

  // goes to right;
  while (labelB.get(succNode.id) == dfsPosNum.get(n.id) && succNode != n1 && succNode != n2) {
    if (!ur.isValid())
      ur = succNode;

    BmdLink<node> *tmp = succItem;
    succItem = RBC[oldCNode].cyclicSucc(succItem, firstItem);
    succNode = succItem->getData();
    RBC[oldCNode].delItem(tmp);
  }

  RBC[oldCNode].delItem(RBC[oldCNode].firstItem());

  // endpoint to correctly concatentates with RBC[new_cnode];
  node first = n1;

  if (!n1.isValid()) {
    if (ul.isValid())
      first = predNode;
    else
      first = succNode;
  }

  // note that oldCNode may have flipped;
  if (RBC[oldCNode].lastItem()->getData() == first)
    RBC[oldCNode].reverse();

  // reoves n1 and n2 from RBC[oldCNode];
  if (n1.isValid()) {
    RBC[oldCNode].delItem(RBC[oldCNode].firstItem());
  }

  if (n2.isValid()) {
    RBC[oldCNode].delItem(RBC[oldCNode].lastItem());
  }

  nodeList.conc(RBC[oldCNode]);
}
Esempio n. 4
0
/*
 * Embeds all edges in a path from w, starting in a back-edge in listBackEdges
 * and ending in repr.
 * Inserts all embedded edges in list embList.
 * Appends all nodes marked as VISITED in list traversed_nodes.
 * emb_back_edges_out_w is false only in case of 2 terminal
 * nodes, for one of the two terminals (see calculate_partial_embedding).
 */
void PlanarityTestImpl::embedBackEdges(bool embBackEdgesOutW,
                                       Graph *sG,
                                       node repr,
                                       list<node>& traversedNodes,
                                       list<edge>& listBackEdges,
                                       tlp::BmdList<edge>& embList) {
  if (listBackEdges.empty())
    return;

  edge e;
  BmdList<edge> el1, l1, wl1;
  //node w = target(listBackEdges.contents(listBackEdges.first()));
  node w = sG->target(listBackEdges.front());

  vector<edge> backEdge;
  int n = sortBackEdgesByDfs(sG, w, repr, listBackEdges, backEdge);

  for(int i = 1; i <= n; i++) {
    e = backEdge[i];

    if (e != NULL_EDGE) {
      if (embBackEdgesOutW)
        wl1.append(edgeReversal( e));
      else
        listBackEdgesOutW.push(edgeReversal( e));
    }
  }

  for(int i = n; i >= 1; i--) {
    e = backEdge[i];

    if (e != NULL_EDGE) {
      l1.push(e);
      node predU = sG->source(e);
      node u = parent.get(predU.id);

      while (state.get(predU.id) == NOT_VISITED) {
        state.set(predU.id, VISITED);
        traversedNodes.push_back(predU);

        if (isCNode(u)) {
          u = activeCNodeOf(false, u);
          embedList[u].conc(l1);
          embedList[u].swap(l1);
          u = parent.get(u.id);
        }
        else {
          l1.push(T0EdgeIn.get(predU.id));
          l1.push(edgeReversal( T0EdgeIn.get(predU.id)));
        }

        predU = u;
        u = parent.get(u.id);
      }

      el1.conc(l1);
    }
  }

  el1.conc(embList);
  el1.swap(embList);
  embList.conc(wl1);
}