コード例 #1
0
 /**
  * Wraps all {@link NodeLayout} objects into an internal presentation {@link NodeWrapper} and
  * inserts dummy wrappers into the layers between an object and their predecessing nodes if
  * necessary. Finally, all nodes are chained over immediate adjacent layers down to their
  * predecessors. This is necessary to apply the final step of the Sugiyama algorithm to refine the
  * node position within a layer.
  *
  * @param list : List of all {@link NodeLayout} objects within the current layer
  */
 private void addLayer(List<NodeLayout> list) {
   ArrayList<NodeWrapper> layer = new ArrayList<NodeWrapper>(list.size());
   for (NodeLayout node : list) {
     // wrap each NodeLayout with the internal data object and provide a
     // corresponding mapping
     NodeWrapper nw = new NodeWrapper(node, layers.size());
     map.put(node, nw);
     layer.add(nw);
     // insert dummy nodes if the adjacent layer does not contain the
     // predecessor
     for (NodeLayout node_predecessor : node.getPredecessingNodes()) { // for
       // all
       // predecessors
       NodeWrapper nw_predecessor = map.get(node_predecessor);
       if (nw_predecessor != null) {
         for (int level = nw_predecessor.layer + 1; level < nw.layer; level++) {
           // add "virtual" wrappers (dummies) to the layers in
           // between
           // virtual wrappers are in fact parts of a double linked
           // list
           NodeWrapper nw_dummy = new NodeWrapper(level);
           nw_dummy.addPredecessor(nw_predecessor);
           nw_predecessor.addSuccessor(nw_dummy);
           nw_predecessor = nw_dummy;
           layers.get(level).add(nw_dummy);
         }
         nw.addPredecessor(nw_predecessor);
         nw_predecessor.addSuccessor(nw);
       }
     }
   }
   layers.add(layer);
   updateIndex(layer);
 }
コード例 #2
0
  public List<List<NodeWrapper>> calculateLayers(
      List<NodeLayout> nodes, Map<NodeLayout, Integer> assignedNodes) {
    // TODO Auto-generated method stub
    map.clear();

    List<NodeLayout> predecessors = findRoots(nodes);
    nodes.removeAll(predecessors); // nodes now contains only nodes that are
    // no roots
    addLayer(predecessors);
    for (int level = 1; nodes.isEmpty() == false; level++) {
      if (level > MAX_LAYERS)
        throw new RuntimeException(
            "Graphical tree exceeds maximum depth of "
                + MAX_LAYERS
                + "! (Graph not directed? Cycles?)");
      List<NodeLayout> layer = new ArrayList<NodeLayout>();
      for (NodeLayout item : nodes) {
        if (predecessors.containsAll(Arrays.asList(item.getPredecessingNodes()))) layer.add(item);
      }
      if (layer.size() == 0) layer.add(nodes.get(0));
      nodes.removeAll(layer);
      predecessors.addAll(layer);
      addLayer(layer);
    }

    return layers;
  }
コード例 #3
0
 private static List<NodeLayout> findRoots(List<NodeLayout> list) {
   List<NodeLayout> roots = new ArrayList<NodeLayout>();
   for (NodeLayout iter : list) { // no predecessors means: this is a root,
     // add it to list
     if (iter.getPredecessingNodes().length == 0) roots.add(iter);
   }
   return (roots);
 }