/**
  * Convenience method, returns the two outgoing from the node the edge points to that does not
  * lead to where the edge comes from
  */
 private Edge[] otherEdges(Edge e) {
   Iterator it = e.pointsTo().getEdges();
   LinkedList ll = new LinkedList();
   while (it.hasNext()) {
     Edge next = (Edge) it.next();
     if (e.getBackEdge() != next) ll.add(next);
   }
   if (ll.size() == 0) return null; // we are looking at a leaf
   return (Edge[]) ll.toArray(new Edge[0]);
 }
  /** Specified in Node */
  protected Node makeBinary(Collection newedges, Edge[] edgemapping, Node caller) {
    // O(n) each edge is visited 1 time in the first part
    // In the second part an upper bound of the total number
    // of runs through the while-loop is O(n) (number of edges).
    Iterator it = edges.iterator();
    Edge e1, e2, newedge1, newedge2, next;
    InnerNode thiscopy = new InnerNode();
    Node tmp;

    // first part (recursion)
    while (it.hasNext()) { // Invoke recursively    //Like the copy-method
      next = (Edge) it.next();
      if (next.to != caller) {
        tmp = next.to.makeBinary(newedges, edgemapping, this);
        e1 = thiscopy.addNeighbour(tmp);
        e2 = tmp.addNeighbour(thiscopy);
        e1.backedge = e2;
        e2.backedge = e1;
        edgemapping[next.getId()] = e1;
        edgemapping[next.getBackEdge().getId()] = e2;
      }
    }

    // second part (fixing degree with a while-loop)
    while ((thiscopy.edges.size() > 2 && caller != null)
        || thiscopy.edges.size() > 3) { // not binary
      // System.out.println(thiscopy+" has "+thiscopy.edges.size()+" edges");
      it = thiscopy.edges.iterator();
      e1 =
          (Edge)
              it.next(); // 1               //Save two outgoing edges (e1 and e2) for binarification
      if (e1.to == caller) e1 = (Edge) it.next(); // 1 or 2
      it.remove(); // Remove this edge from the edge list, see why below **
      e2 = (Edge) it.next(); // 2 or 3
      if (e2.to == caller)
        e2 =
            (Edge)
                it
                    .next(); // 3  //since edges.size() >=4 I can get three elements out without
                             // problems
      it.remove(); // Remove this edge from the edge list, see why below **

      // e1 and e2 are two outgoing edges that does not lead back to the caller

      InnerNode newnode = new InnerNode(); // Make a new node to attach e1 and e2 to

      newedge1 = thiscopy.addNeighbour(newnode); // attach this node to the new node
      newedge2 = newnode.addNeighbour(thiscopy); // and vice versa
      newedge1.backedge = newedge2;
      newedge2.backedge = newedge1;
      newedges.add(newedge1); // Since these edges are new edges, add them to the collection
      newedges.add(newedge2);

      // Now instead of using removeNeighbour and that stuff, we use a 'hack'. We change the
      // endpoint of the
      // edges between 'e1' and 'thiscopy' to 'e1' and 'newnode', and 'e2' and 'thiscopy' to 'e2'
      // and 'newnode' respectively.
      // This way any new edge already added to the newedges-collection is still valid.

      e1.from = newnode; // change the endpoints
      e2.from = newnode;
      e1.getBackEdge().to = newnode; //
      e2.getBackEdge().to = newnode;

      // now we need to remove e1 and e2 from this nodes edgelist and add them to newnode's edge
      // list, but we
      // already did half of that above **
      newnode.edges.add(e1);
      newnode.edges.add(e2); // the other half well done.

      // For each run of this while-loop one neighbour is added and two are removed, hence it must
      // terminate.
    }

    return thiscopy;
  }