/** @see prefuse.action.Action#run(double) */
  public void run(double frac) {

    Graph g = (Graph) m_vis.getGroup(m_group);
    initSchema(g.getNodes());

    m_origin = getLayoutAnchor();
    NodeItem n = getLayoutRoot();
    Params np = (Params) n.get(PARAMS);

    // calc relative widths and maximum tree depth
    // performs one pass over the tree
    m_maxDepth = 0;
    calcAngularWidth(n, 0);

    if (m_autoScale) setScale(getLayoutBounds());
    if (!m_setTheta) calcAngularBounds(n);

    // perform the layout
    if (m_maxDepth > 0) layout(n, m_radiusInc, m_theta1, m_theta2);

    // update properties of the root node
    setX(n, null, m_origin.getX());
    setY(n, null, m_origin.getY());
    np.angle = m_theta2 - m_theta1;
  }
 public void process(VisualItem item, double frac) {
   // if (item instanceof Node ){
   // int dp = item.getDepth()+1;
   // double incfactor =
   NodeItem tn = ((EdgeItem) item).getTargetItem();
   int nc = tn.getInt(NODECOUNT);
   if (nc == 1) {
     System.err.println("hiding___" + item);
     PrefuseLib.updateVisible(tn, false);
     PrefuseLib.updateVisible(item, false);
   }
 }
예제 #3
0
 /*
  * Test method for 'prefuse.Visualization.getSourceTuple(VisualItem)'
  */
 @Test
 public void testGetSourceTuple() {
   Assert.assertEquals(m_t0, m_vis.getSourceTuple(m_vt0));
   Assert.assertEquals(m_n0, m_vis.getSourceTuple(m_vn0));
   Assert.assertEquals(m_t0, m_vt0.getSourceTuple());
   Assert.assertEquals(m_n0, m_vn0.getSourceTuple());
 }
예제 #4
0
  /*
   * Test method for 'prefuse.Visualization.getSourceData(String)'
   */
  @Test
  public void testGetSourceData() {
    Assert.assertEquals(m_t, m_vis.getSourceData("t"));
    Assert.assertEquals(m_t, m_vt0.getSourceData());

    Assert.assertEquals(m_g, m_vis.getSourceData("g"));
    Assert.assertEquals(m_g.getNodeTable(), m_vis.getSourceData("g.nodes"));
    Assert.assertEquals(m_g.getEdgeTable(), m_vis.getSourceData("g.edges"));
    Assert.assertEquals(m_g.getNodeTable(), m_vn0.getSourceData());
  }
  /**
   * Compute the layout.
   *
   * @param n the root of the current subtree under consideration
   * @param r the radius, current distance from the center
   * @param theta1 the start (in radians) of this subtree's angular region
   * @param theta2 the end (in radians) of this subtree's angular region
   */
  protected void layout(NodeItem n, double r, double theta1, double theta2) {
    double dtheta = (theta2 - theta1);
    double dtheta2 = dtheta / 2.0;
    double width = ((Params) n.get(PARAMS)).width;
    double cfrac, nfrac = 0.0;

    Iterator childIter = sortedChildren(n);
    while (childIter != null && childIter.hasNext()) {
      NodeItem c = (NodeItem) childIter.next();
      Params cp = (Params) c.get(PARAMS);
      cfrac = cp.width / width;
      if (c.isExpanded() && c.getChildCount() > 0) {
        layout(c, r + m_radiusInc, theta1 + nfrac * dtheta, theta1 + (nfrac + cfrac) * dtheta);
      }
      setPolarLocation(c, n, r, theta1 + nfrac * dtheta + cfrac * dtheta2);

      cp.angle = cfrac * dtheta;
      nfrac += cfrac;
    }
  }
예제 #6
0
  // TODO: cache required
  protected int getEdgeIndex(EdgeItem e) {
    if (isIgnored(e)) {
      return -1;
    }

    NodeItem sourceItem = e.getSourceItem();
    NodeItem targetItem = e.getTargetItem();
    Iterator<EdgeItem> edges = sourceItem.edges();

    // number of equal edges = same target and source
    int equalEdges = 0;
    // number of nearequal edges = same nodes, but any order target and source
    int sameEdges = 0;
    int edgeIndex = 0;
    int row = e.getRow();
    while (edges.hasNext()) {
      EdgeItem edge = edges.next();
      int edgeRow = edge.getRow();
      if (isIgnored(edge)) {
        continue;
      }
      if (edge.getSourceItem() == sourceItem && edge.getTargetItem() == targetItem) {
        if (row == edgeRow) {
          edgeIndex = equalEdges;
        }
        equalEdges++;
        sameEdges++;
      } else if (edge.getSourceItem() == targetItem && edge.getTargetItem() == sourceItem) {
        sameEdges++;
      }
    }

    // draw the line straight if we found one edge
    if (lineForSingleEdge && edgeIndex == 0 && sameEdges == 1) {
      return -1;
    } else if (sameEdges > 1) {
      edgeIndex++;
    }

    return edgeIndex;
  }
  /**
   * Computes relative measures of the angular widths of each expanded subtree. Node diameters are
   * taken into account to improve space allocation for variable-sized nodes.
   *
   * <p>This method also updates the base angle value for nodes to ensure proper ordering of nodes.
   */
  private double calcAngularWidth(NodeItem n, int d) {
    if (d > m_maxDepth) m_maxDepth = d;
    double aw = 0;

    Rectangle2D bounds = n.getBounds();
    double w = bounds.getWidth(), h = bounds.getHeight();
    double diameter = d == 0 ? 0 : Math.sqrt(w * w + h * h) / d;

    if (n.isExpanded() && n.getChildCount() > 0) {
      Iterator childIter = n.children();
      while (childIter.hasNext()) {
        NodeItem c = (NodeItem) childIter.next();
        aw += calcAngularWidth(c, d + 1);
      }
      aw = Math.max(diameter, aw);
    } else {
      aw = diameter;
    }
    ((Params) n.get(PARAMS)).width = aw;
    return aw;
  }
  /**
   * Calculates the angular bounds of the layout, attempting to preserve the angular orientation of
   * the display across transitions.
   */
  private void calcAngularBounds(NodeItem r) {
    if (m_prevRoot == null || !m_prevRoot.isValid() || r == m_prevRoot) {
      m_prevRoot = r;
      return;
    }

    // try to find previous parent of root
    NodeItem p = m_prevRoot;
    while (true) {
      NodeItem pp = (NodeItem) p.getParent();
      if (pp == r) {
        break;
      } else if (pp == null) {
        m_prevRoot = r;
        return;
      }
      p = pp;
    }

    // compute offset due to children's angular width
    double dt = 0;
    Iterator iter = sortedChildren(r);
    while (iter.hasNext()) {
      Node n = (Node) iter.next();
      if (n == p) break;
      dt += ((Params) n.get(PARAMS)).width;
    }
    double rw = ((Params) r.get(PARAMS)).width;
    double pw = ((Params) p.get(PARAMS)).width;
    dt = -MathLib.TWO_PI * (dt + pw / 2) / rw;

    // set angular bounds
    m_theta1 = dt + Math.atan2(p.getY() - r.getY(), p.getX() - r.getX());
    m_theta2 = m_theta1 + MathLib.TWO_PI;
    m_prevRoot = r;
  }
예제 #9
0
  public Display getGraphDisplay(
      GraphLayoutType glType, final ExperimentPanel expPanel, String highlightName) {
    Display display = new Display();
    int X = expPanel.getDetailWidth();
    int Y = expPanel.getDetailHeight();
    display.setSize(X, Y); // set display size
    // display.setHighQuality(true);
    // display.setPreferredSize(new Dimension(600,600));
    display.addControlListener(new DragControl()); // drag items around
    display.addControlListener(new PanControl()); // pan with background left-drag
    display.addControlListener(new WheelZoomControl()); // zoom with vertical right-drag
    display.addControlListener(
        new ZoomToFitControl(Visualization.ALL_ITEMS, 50, 500, Control.MIDDLE_MOUSE_BUTTON));
    display.addControlListener(new NeighborHighlightControl());

    Visualization vis = new Visualization();
    if (clusterGraph == null) {
      clusterGraph = this.toGraph();
    }
    vis.add("graph", clusterGraph);
    LabelRenderer r = new LabelRenderer("name");
    r.setHorizontalAlignment(Constants.CENTER);
    // r.setRoundedCorner(8, 8); // round the corners

    DefaultRendererFactory rf = new DefaultRendererFactory(r);
    rf.setDefaultEdgeRenderer(new EdgeRenderer(Constants.EDGE_TYPE_CURVE));
    vis.setRendererFactory(rf);
    int[] palette = new int[] {ColorLib.rgb(255, 180, 180), ColorLib.rgb(190, 190, 255)};
    DataColorAction fill =
        new DataColorAction(
            "graph.nodes", "type", Constants.NOMINAL, VisualItem.FILLCOLOR, palette);
    fill.add(VisualItem.FIXED, ColorLib.rgb(255, 100, 100));
    fill.add(VisualItem.HIGHLIGHT, ColorLib.rgb(255, 200, 125));
    int[] text_palette = new int[] {ColorLib.gray(0), ColorLib.gray(255)};
    DataColorAction text =
        new DataColorAction(
            "graph.nodes",
            "indeterminate",
            Constants.NUMERICAL,
            VisualItem.TEXTCOLOR,
            text_palette);
    // ColorAction text = new ColorAction("graph.nodes", VisualItem.TEXTCOLOR, ColorLib.gray(0));
    ColorAction edges = new ColorAction("graph.edges", VisualItem.STROKECOLOR, ColorLib.gray(200));

    ActionList color = new ActionList(Activity.INFINITY);
    color.add(text);
    color.add(fill);
    color.add(edges);
    color.add(new RepaintAction());

    if (highlightName != null) {
      String pred = "name='" + highlightName + "'";
      Iterator iter = vis.items("graph.nodes", ExpressionParser.predicate(pred));
      while (iter.hasNext()) {
        NodeItem ni = (NodeItem) iter.next();
        highlightedItem = ni;
        ni.setFixed(true);
        Iterator iterEdge = ni.edges();
        while (iterEdge.hasNext()) {
          EdgeItem eItem = (EdgeItem) iterEdge.next();
          NodeItem nItem = eItem.getAdjacentItem(ni);
          if (eItem.isVisible()) {
            eItem.setHighlighted(true);
            nItem.setHighlighted(true);
          }
        }
      }
    }

    ActionList layout = new ActionList();
    switch (glType) {
      case BALLOON_TREE:
        layout.add(new BalloonTreeLayout("graph"));
        break;
      case FORCE_DIRECTED:
        layout = new ActionList(Activity.INFINITY);
        layout.add(new ForceDirectedLayout("graph"));
        break;
      case NODE_LINK_TREE:
        layout.add(new NodeLinkTreeLayout("graph"));
        break;
      case RADIAL_TREE:
        layout.add(new RadialTreeLayout("graph"));
        break;
    }
    // layout.add(fill);
    layout.add(new RepaintAction());

    vis.putAction("color", color);
    vis.putAction("layout", layout);
    display.setVisualization(vis);
    vis.run("color");
    vis.run("layout");
    // Rectangle2D bounds = vis.getBounds(Visualization.ALL_ITEMS);
    // GraphicsLib.expand(bounds, 50 + (int)(1/display.getScale()));
    // DisplayLib.fitViewToBounds(display,bounds,1);
    // vis.runAfter("layout",1000);

    Control shutoffHighlight =
        new HoverActionControl("color") {
          // public void itemEntered(VisualItem item, MouseEvent evt) {
          // }
          public void itemExited(VisualItem item, MouseEvent evt) {
            if (highlightedItem != null) {
              highlightedItem.setFixed(false);
              Iterator iterEdge = highlightedItem.edges();
              while (iterEdge.hasNext()) {
                EdgeItem eItem = (EdgeItem) iterEdge.next();
                NodeItem nItem = eItem.getAdjacentItem(highlightedItem);
                if (eItem.isVisible()) {
                  eItem.setHighlighted(false);
                  nItem.setHighlighted(false);
                }
              }
              highlightedItem = null;
            }
          }
        };
    display.addControlListener(shutoffHighlight);

    Control selectItem =
        new FocusControl() {

          public void itemClicked(VisualItem item, MouseEvent evt) {
            if (item.isInGroup("graph.nodes")) {
              if (item.getString("type").equals("peptide")) {
                Peptide pep = minPeptides.get(item.getString("name"));
                expPanel.showPeptide(pep, true);
              }
              if (item.getString("type").equals("protein")) {
                Protein pro = minProteins.get(item.getString("name"));
                expPanel.showProtein(pro, true);
              }
              String pred = "name='" + item.getString("name") + "'";
              Iterator iter =
                  item.getVisualization().items("graph.nodes", ExpressionParser.predicate(pred));
              while (iter.hasNext()) {
                NodeItem ni = (NodeItem) iter.next();
                highlightedItem = ni;
                ni.setFixed(true);
                Iterator iterEdge = ni.edges();
                while (iterEdge.hasNext()) {
                  EdgeItem eItem = (EdgeItem) iterEdge.next();
                  NodeItem nItem = eItem.getAdjacentItem(ni);
                  if (eItem.isVisible()) {
                    eItem.setHighlighted(true);
                    nItem.setHighlighted(true);
                  }
                }
              }
            }
          }
        };
    display.addControlListener(selectItem);

    final JPopupMenu menu = new JPopupMenu();

    // Create and add a menu item
    // JMenuItem printItem = new JMenuItem("Print This");
    // printItem.addActionListener(new java.awt.event.ActionListener() {

    //    public void actionPerformed(java.awt.event.ActionEvent evt) {
    //        PrintUtilities.printComponent(display);
    //    }
    // });
    // menu.add(printItem);

    // Set the component to show the popup menu
    display.addMouseListener(
        new MouseAdapter() {

          public void mousePressed(MouseEvent evt) {
            if (evt.isPopupTrigger()) {
              menu.show(evt.getComponent(), evt.getX(), evt.getY());
            }
          }

          public void mouseReleased(MouseEvent evt) {
            if (evt.isPopupTrigger()) {
              menu.show(evt.getComponent(), evt.getX(), evt.getY());
            }
          }
        });
    display.pan(X / 2.0, Y / 2.0);
    return display;
  }
예제 #10
0
  private Iterator sortedChildren(final NodeItem n) {
    double base = 0;
    // update base angle for node ordering
    NodeItem p = (NodeItem) n.getParent();
    if (p != null) {
      base = normalize(Math.atan2(p.getY() - n.getY(), p.getX() - n.getX()));
    }
    int cc = n.getChildCount();
    if (cc == 0) return null;

    NodeItem c = (NodeItem) n.getFirstChild();

    if (!c.isStartVisible()) {
      // use natural ordering for previously invisible nodes
      return n.children();
    }

    double angle[] = new double[cc];
    final int idx[] = new int[cc];
    for (int i = 0; i < cc; ++i, c = (NodeItem) c.getNextSibling()) {
      idx[i] = i;
      angle[i] = normalize(-base + Math.atan2(c.getY() - n.getY(), c.getX() - n.getX()));
    }
    ArrayLib.sort(angle, idx);

    // return iterator over sorted children
    return new Iterator() {
      int cur = 0;

      public Object next() {
        return n.getChild(idx[cur++]);
      }

      public boolean hasNext() {
        return cur < idx.length;
      }

      public void remove() {
        throw new UnsupportedOperationException();
      }
    };
  }